Files
skillshare/internal/server/handler_agent_diff.go
T
Willie 72ed5ba0fb fix(diff): compare extension agent outputs and apply target filters (#414)
* fix(diff): compare extension agent outputs and apply target filters

#392 taught status and doctor to recognise converted extension outputs,
but diff (CLI) and the Sync tab (/api/diff) still compared the target
directory's *.md files against the source name. A target whose extension
renames the output (codex -> .toml) therefore listed every agent as
pending after a sync.

Both diff paths now use the same manifest-based check as status, and
report tracked outputs whose source is gone as prune items. They also
apply the target's include/exclude and the agents' frontmatter targets,
so an agent that sync would skip is no longer shown as pending.

Refs #391

* chore(release): request 0.24.6

The pending feat commits would make Release Please propose 0.25.0. This
batch is meant to ship as the 0.24.6 patch, so ask for that version.

Release-As: 0.24.6
2026-10-05 15:40:19 +08:00

143 lines
3.6 KiB
Go

package server
import (
"os"
"path/filepath"
"strings"
"skillshare/internal/config"
"skillshare/internal/resource"
"skillshare/internal/sync"
"skillshare/internal/utils"
)
// computeAgentTargetDiff computes diff items for agents in a single target directory.
// Returns items with Kind="agent" for each pending action (link, update, prune, local).
// Like sync, it applies the target's include/exclude and the agents' frontmatter
// targets first, and a target with an extension compares the converted outputs
// recorded in its manifest.
func computeAgentTargetDiff(targetName, targetDir string, ac config.ResourceTargetConfig, agents []resource.DiscoveredResource) []diffItem {
var items []diffItem
filtered, err := sync.FilterAgents(agents, ac.Include, ac.Exclude)
if err != nil {
filtered = agents // invalid include/exclude: sync reports it
}
agents = sync.FilterAgentsByTarget(filtered, targetName)
if ac.Extension != "" {
synced, orphans := sync.ExtensionOutputStatus(targetDir, agents)
for i, a := range agents {
if !synced[i] {
items = append(items, diffItem{
Skill: a.FlatName,
Action: "link",
Reason: "output missing or outdated",
Kind: kindAgent,
})
}
}
for _, name := range orphans {
items = append(items, diffItem{
Skill: name,
Action: "prune",
Reason: "orphan output",
Kind: kindAgent,
})
}
return items
}
// Build expected set
expected := make(map[string]resource.DiscoveredResource, len(agents))
for _, a := range agents {
expected[a.FlatName] = a
}
// Read existing .md files in target
existing := make(map[string]os.FileMode)
if entries, err := os.ReadDir(targetDir); err == nil {
for _, e := range entries {
if e.IsDir() || !strings.HasSuffix(strings.ToLower(e.Name()), ".md") {
continue
}
if resource.ConventionalExcludes[e.Name()] {
continue
}
existing[e.Name()] = e.Type()
}
}
// Missing agents → link
for flatName, agent := range expected {
fileType, ok := existing[flatName]
if !ok {
items = append(items, diffItem{
Skill: flatName,
Action: "link",
Reason: "source only",
Kind: kindAgent,
})
continue
}
// Exists — check if symlink points to correct source
targetPath := filepath.Join(targetDir, flatName)
if fileType&os.ModeSymlink != 0 || utils.IsSymlinkOrJunction(targetPath) {
absLink, err := utils.ResolveLinkTarget(targetPath)
if err != nil {
items = append(items, diffItem{
Skill: flatName,
Action: "update",
Reason: "link target unreadable",
Kind: kindAgent,
})
continue
}
absSource, _ := filepath.Abs(agent.AbsPath)
if !utils.PathsEqual(absLink, absSource) {
items = append(items, diffItem{
Skill: flatName,
Action: "update",
Reason: "symlink points elsewhere",
Kind: kindAgent,
})
}
continue
}
// Match skills diff semantics: a local file blocks sync unless forced.
items = append(items, diffItem{
Skill: flatName,
Action: "skip",
Reason: "local copy (sync --force to replace)",
Kind: kindAgent,
})
}
// Orphan/local detection
for name, fileType := range existing {
if _, ok := expected[name]; ok {
continue
}
targetPath := filepath.Join(targetDir, name)
if fileType&os.ModeSymlink != 0 || utils.IsSymlinkOrJunction(targetPath) {
items = append(items, diffItem{
Skill: name,
Action: "prune",
Reason: "orphan symlink",
Kind: kindAgent,
})
} else {
items = append(items, diffItem{
Skill: name,
Action: "local",
Reason: "local file",
Kind: kindAgent,
})
}
}
return items
}