Files
skillshare/internal/server/handler_sync_matrix.go
T
Willie 89fc4fbdf1 feat(sourcewalk): follow first-level source links when enabled
Users link a checkout directly under the skills source (e.g.
skills/_dev-skills -> ~/code/dev-skills) and expect it to behave like any
other first-level entry. sourcewalk resolved only the root, so these links
were invisible to discovery, sync, update, and the dashboard.

follow_source_links (global and project config, default false) enables a
per-operation sourcewalk.Follow policy. Walk, WalkDir, and ReadDir report a
followed link under its own name as a directory and descend into its
target, so names, RelPath, FlatName, SourcePath, tracked-repo detection, and
metadata keys stay logical. Only entries directly under the source root are
followed. The policy is built from config and passed explicitly to every
discovery caller in the CLI, server, and reconcile, so counts agree; the
server keeps a per-instance snapshot refreshed on config load and save
instead of a process-global flag.

A link is skipped, with one warning per operation, when its target is
missing or unreadable, is the source or a parent of it, or overlaps an
active skills target. A missing or unreadable target marks the operation
incomplete: sync then skips pruning and copy-orphan deletion, and reconcile
keeps metadata, so an unmounted drive or a re-clone in progress cannot
erase target entries or install records. A link to an existing file is not
a directory link and stays an ordinary entry; treating it as incomplete
would disable pruning for anyone sharing a file such as .skillignore.

doctor keeps raw link identity: with the key off it still says the link is
not followed and names follow_source_links: true; with it on it reports
followed links and skipped links with the reason.

The raw-walk allowlist gains entries for the policy path in Walk and
WalkDir: the source root walk with a policy, and the walk of a validated
link target whose paths are remapped to the logical link path. Both live
in sourcewalk itself, the package that owns source traversal.

Refs #274
2026-10-05 14:26:09 +08:00

238 lines
7.6 KiB
Go

package server
import (
"errors"
"net/http"
"strings"
"skillshare/internal/config"
"skillshare/internal/resource"
ssync "skillshare/internal/sync"
)
type syncMatrixEntry struct {
Skill string `json:"skill"`
Target string `json:"target"`
Status string `json:"status"`
Reason string `json:"reason"`
ReasonCode string `json:"reasonCode,omitempty"`
ReasonParams map[string]string `json:"reasonParams,omitempty"`
Kind string `json:"kind,omitempty"`
}
func syncMatrixReason(status, reason string) (string, map[string]string) {
if reason == "symlink mode — filters not applicable" {
return "sync_matrix.symlink_filters_not_applicable", nil
}
switch status {
case "synced":
return "sync_matrix.synced", nil
case "excluded":
return "sync_matrix.excluded", map[string]string{"pattern": reason}
case "not_included":
return "sync_matrix.not_included", nil
case "skill_target_mismatch":
return "sync_matrix.skill_target_mismatch", nil
default:
return "", nil
}
}
// agentFilterName is the name agent filter patterns match against, mirroring ssync.FilterAgents.
func agentFilterName(flatName string) string {
return strings.TrimSuffix(flatName, ".md")
}
func newSyncMatrixEntry(skill, target, status, reason, kind string) syncMatrixEntry {
reasonCode, reasonParams := syncMatrixReason(status, reason)
return syncMatrixEntry{
Skill: skill,
Target: target,
Status: status,
Reason: reason,
ReasonCode: reasonCode,
ReasonParams: reasonParams,
Kind: kind,
}
}
func (s *Server) handleSyncMatrix(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
agentsSource := s.agentsSource()
targets := s.cloneTargets()
s.mu.RUnlock()
skills, err := ssync.DiscoverSourceSkills(source, s.skillsWalk())
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
var agents []resource.DiscoveredResource
if agentsSource != "" {
discovered, _ := resource.AgentKind{}.Discover(agentsSource)
agents = resource.ActiveAgents(discovered)
}
var builtinAgents map[string]config.TargetConfig
if s.IsProjectMode() {
builtinAgents = config.ProjectAgentTargets()
} else {
builtinAgents = config.DefaultAgentTargets()
}
targetFilter := r.URL.Query().Get("target")
var entries []syncMatrixEntry
for name, target := range targets {
if targetFilter != "" && name != targetFilter {
continue
}
// Skills
sc := target.SkillsConfig()
if !sc.IsEnabled() {
for _, skill := range skills {
entries = append(entries, newSyncMatrixEntry(skill.FlatName, name, "na", "skills off for this target", ""))
}
} else if sc.Mode == "symlink" {
for _, skill := range skills {
entries = append(entries, newSyncMatrixEntry(skill.FlatName, name, "na", "symlink mode — filters not applicable", ""))
}
} else {
for _, skill := range skills {
status, reason := ssync.ClassifySkillForTarget(skill.FlatName, skill.Targets, name, sc.Include, sc.Exclude)
entries = append(entries, newSyncMatrixEntry(skill.FlatName, name, status, reason, ""))
}
}
// Agents — resolve path from user config or builtin defaults
ac := target.AgentsConfig()
agentPath := ac.Path
if agentPath == "" {
if builtin, ok := builtinAgents[name]; ok {
agentPath = builtin.Path
}
}
if agentPath == "" || len(agents) == 0 {
continue
}
agentMode := ac.Mode
if agentMode == "" {
agentMode = "merge"
}
if agentMode == "symlink" {
for _, agent := range agents {
entries = append(entries, newSyncMatrixEntry(agent.FlatName, name, "na", "symlink mode — filters not applicable", "agent"))
}
} else {
for _, agent := range agents {
status, reason := ssync.ClassifySkillForTarget(agentFilterName(agent.FlatName), agent.Targets, name, ac.Include, ac.Exclude)
entries = append(entries, newSyncMatrixEntry(agent.FlatName, name, status, reason, "agent"))
}
}
}
writeJSON(w, map[string]any{"entries": entries})
}
func (s *Server) handleSyncMatrixPreview(w http.ResponseWriter, r *http.Request) {
// Snapshot config under RLock, then release before I/O.
s.mu.RLock()
source := s.cfg.EffectiveSkillsSource()
agentsSource := s.agentsSource()
targets := s.cloneTargets()
s.mu.RUnlock()
var body struct {
Target string `json:"target"`
Include []string `json:"include"`
Exclude []string `json:"exclude"`
AgentInclude []string `json:"agent_include"`
AgentExclude []string `json:"agent_exclude"`
}
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); err != nil {
if !errors.Is(err, errBodyTooLarge) {
writeError(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
}
return
}
if body.Target == "" {
writeError(w, http.StatusBadRequest, "target is required")
return
}
// Validate skill patterns
if _, err := ssync.FilterSkills(nil, body.Include, nil); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
if _, err := ssync.FilterSkills(nil, nil, body.Exclude); err != nil {
writeError(w, http.StatusBadRequest, err.Error())
return
}
// Validate agent patterns
if _, err := ssync.FilterSkills(nil, body.AgentInclude, nil); err != nil {
writeError(w, http.StatusBadRequest, "invalid agent include pattern: "+err.Error())
return
}
if _, err := ssync.FilterSkills(nil, nil, body.AgentExclude); err != nil {
writeError(w, http.StatusBadRequest, "invalid agent exclude pattern: "+err.Error())
return
}
skills, err := ssync.DiscoverSourceSkills(source, s.skillsWalk())
if err != nil {
writeError(w, http.StatusInternalServerError, "failed to discover skills: "+err.Error())
return
}
var entries []syncMatrixEntry
for _, skill := range skills {
status, reason := ssync.ClassifySkillForTarget(skill.FlatName, skill.Targets, body.Target, body.Include, body.Exclude)
entries = append(entries, newSyncMatrixEntry(skill.FlatName, body.Target, status, reason, ""))
}
// Agents — resolve path from config or builtin defaults
target, ok := targets[body.Target]
_, projectTool, isProject := config.SplitProjectTarget(body.Target)
if (ok || isProject) && agentsSource != "" {
ac := target.AgentsConfig()
agentPath := ac.Path
if agentPath == "" {
var previewBuiltin map[string]config.TargetConfig
if s.IsProjectMode() {
previewBuiltin = config.ProjectAgentTargets()
} else {
previewBuiltin = config.DefaultAgentTargets()
}
if builtin, found := previewBuiltin[body.Target]; found {
agentPath = builtin.Path
}
// A project's draft can turn agents on before the project is saved.
if builtin, found := config.LookupProjectAgentTarget(projectTool); isProject && found {
agentPath = builtin.Path
}
}
if agentPath != "" {
discovered, _ := resource.AgentKind{}.Discover(agentsSource)
agents := resource.ActiveAgents(discovered)
agentMode := ac.Mode
if agentMode == "" {
agentMode = "merge"
}
if agentMode == "symlink" {
for _, agent := range agents {
entries = append(entries, newSyncMatrixEntry(agent.FlatName, body.Target, "na", "symlink mode — filters not applicable", "agent"))
}
} else {
for _, agent := range agents {
status, reason := ssync.ClassifySkillForTarget(agentFilterName(agent.FlatName), agent.Targets, body.Target, body.AgentInclude, body.AgentExclude)
entries = append(entries, newSyncMatrixEntry(agent.FlatName, body.Target, status, reason, "agent"))
}
}
}
}
writeJSON(w, map[string]any{"entries": entries})
}