mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +00:00
Dashboard sync and project sync JSON scanned the agents source again just for the ignore summary. Carry the full discovery snapshot through sync so the response describes the agents that were synced, including ignored ones. Skills-only syncs keep the existing fallback scan. Cover the handler and project JSON paths when the source changes after discovery. Check syncProject returns ignored agents and an empty discovery stays non-nil through execution, so neither path silently rescans. Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
457 lines
15 KiB
Go
457 lines
15 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"maps"
|
|
"net/http"
|
|
"slices"
|
|
"sort"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/projects"
|
|
"skillshare/internal/resource"
|
|
"skillshare/internal/skillignore"
|
|
ssync "skillshare/internal/sync"
|
|
"skillshare/internal/utils"
|
|
)
|
|
|
|
// ignorePayload builds the common ignored-skills fields for JSON responses.
|
|
func ignorePayload(stats *skillignore.IgnoreStats) map[string]any {
|
|
r := ssync.NewIgnoreReport(stats, "", nil)
|
|
return map[string]any{
|
|
"ignored_count": r.IgnoredCount,
|
|
"ignored_skills": r.IgnoredSkills,
|
|
"ignore_root": r.IgnoreRoot,
|
|
"ignore_repos": r.IgnoreRepos,
|
|
}
|
|
}
|
|
|
|
type syncFailure = ssync.TargetFailure
|
|
type unmatchedInclude = ssync.TargetUnmatchedInclude
|
|
type syncTargetResult = ssync.TargetResult
|
|
|
|
func (s *Server) handleSync(w http.ResponseWriter, r *http.Request) {
|
|
start := time.Now()
|
|
s.mu.Lock()
|
|
defer s.mu.Unlock()
|
|
|
|
var body struct {
|
|
DryRun bool `json:"dryRun"`
|
|
Force bool `json:"force"`
|
|
Kind string `json:"kind"`
|
|
// Project limits the sync to one declared project's targets.
|
|
Project string `json:"project"`
|
|
}
|
|
if err := decodeJSON(w, r, &body, defaultJSONBodyLimit); errors.Is(err, errBodyTooLarge) {
|
|
return
|
|
}
|
|
// Any other decode error keeps the defaults: non-dry-run, non-force, empty kind (both)
|
|
|
|
if body.Kind != "" && body.Kind != kindSkill && body.Kind != kindAgent {
|
|
writeError(w, http.StatusBadRequest, "invalid kind: must be 'skill', 'agent', or empty")
|
|
return
|
|
}
|
|
|
|
if body.Project != "" {
|
|
root, lookupErr := lookupProjectRoot(s.cfg.Projects, body.Project)
|
|
if lookupErr != nil && !errors.Is(lookupErr, projects.ErrNotFound) {
|
|
writeError(w, http.StatusBadRequest, lookupErr.Error())
|
|
return
|
|
}
|
|
if _, ok := s.cfg.Projects[root]; !ok {
|
|
writeError(w, http.StatusBadRequest, "unknown project: "+body.Project)
|
|
return
|
|
}
|
|
body.Project = root
|
|
}
|
|
|
|
out, code, err := s.syncResources(start, body.DryRun, body.Force, body.Kind, body.Project)
|
|
if err != nil {
|
|
writeError(w, code, err.Error())
|
|
return
|
|
}
|
|
|
|
resp := map[string]any{
|
|
"results": out.results,
|
|
"warnings": out.warnings,
|
|
"unmatched": out.unmatched,
|
|
"failed": out.failed,
|
|
"folder_conflicts": out.folderConflicts,
|
|
"path_overlap": out.pathOverlap,
|
|
}
|
|
if len(out.skills) > 0 {
|
|
if contextCost := s.computeContextCost(out.skills); contextCost != nil {
|
|
resp["context_cost"] = contextCost
|
|
}
|
|
}
|
|
maps.Copy(resp, ignorePayload(out.ignoreStats))
|
|
maps.Copy(resp, agentIgnorePayload(s.agentsSource(), out.allAgents))
|
|
writeJSON(w, resp)
|
|
}
|
|
|
|
type syncOutcome struct {
|
|
results []syncTargetResult
|
|
warnings []string
|
|
unmatched []unmatchedInclude
|
|
failed []syncFailure
|
|
folderConflicts []config.SkillsFolderConflict
|
|
pathOverlap int // targets whose path overlap the folder conflicts don't explain
|
|
skills []ssync.DiscoveredSkill
|
|
ignoreStats *skillignore.IgnoreStats
|
|
allAgents []resource.DiscoveredResource // nil when agents were not synced
|
|
}
|
|
|
|
// folderConflicts returns the skills folders whose targets undo each other's
|
|
// sync, never nil, plus how many targets overlap in a way they don't explain.
|
|
// harmless is passed on to config.DetectPathOverlap.
|
|
func folderConflicts(targets map[string]config.TargetConfig, isProject bool, defaultMode string, harmless func(scanner, writer string) bool) ([]config.SkillsFolderConflict, int) {
|
|
return ssync.TargetFolderConflicts(targets, isProject, defaultMode, harmless)
|
|
}
|
|
|
|
// projectTargets returns the targets of the project declared under root.
|
|
func (s *Server) projectTargets(root string) map[string]config.TargetConfig {
|
|
abs := config.ExpandPath(root)
|
|
targets := map[string]config.TargetConfig{}
|
|
for name, target := range s.cfg.Targets {
|
|
if target.ProjectRoot() != "" && utils.PathsEqual(target.ProjectRoot(), abs) {
|
|
targets[name] = target
|
|
}
|
|
}
|
|
return targets
|
|
}
|
|
|
|
// syncResources links skills and agents (kind "" means both) into every target,
|
|
// or only the targets of the project declared under project, and logs the sync.
|
|
// A failed target, even when every target fails, is reported in failed and
|
|
// warnings; an error, with the HTTP status to report, means nothing could run.
|
|
// Callers must hold s.mu.
|
|
func (s *Server) syncResources(start time.Time, dryRun, force bool, kind, project string) (*syncOutcome, int, error) {
|
|
targets := s.cfg.Targets
|
|
if project != "" {
|
|
targets = s.projectTargets(project)
|
|
}
|
|
|
|
// Pre-check warnings via shared config validation
|
|
warnings, invalid, validErr := config.ValidateConfigForSync(s.cfg)
|
|
if validErr != nil {
|
|
return nil, http.StatusBadRequest, validErr
|
|
}
|
|
|
|
// A project target that cannot resolve (no path) is not in s.cfg.Targets;
|
|
// it fails like one with invalid settings.
|
|
maps.Copy(invalid, s.unresolvedTargets)
|
|
total := len(targets) + len(s.unresolvedTargets)
|
|
|
|
results := make([]syncTargetResult, 0)
|
|
failed := make([]syncFailure, 0)
|
|
unmatched := make([]unmatchedInclude, 0)
|
|
|
|
// A target with invalid settings fails alone: it is skipped for skills and agents.
|
|
runTargets := maps.Clone(targets)
|
|
for _, name := range slices.Sorted(maps.Keys(invalid)) {
|
|
if _, ok := targets[name]; !ok && s.unresolvedTargets[name] == nil {
|
|
continue
|
|
}
|
|
delete(runTargets, name)
|
|
err := invalid[name]
|
|
msg := name + ": invalid config: " + err.Error()
|
|
warnings = append(warnings, msg)
|
|
failed = append(failed, syncFailure{Target: name, Part: "config", Error: err.Error(), Message: msg})
|
|
}
|
|
|
|
if !dryRun {
|
|
warnings = append(warnings, s.backupBeforeSync(runTargets, kind != kindAgent, kind != kindSkill)...)
|
|
}
|
|
|
|
var ignoreStats *skillignore.IgnoreStats
|
|
var allSkills []ssync.DiscoveredSkill
|
|
var sourceIncomplete bool
|
|
|
|
// Skill sync (skip when kind == "agent")
|
|
if kind != kindAgent {
|
|
var err error
|
|
if !dryRun {
|
|
if adoptErr := s.adoptMovedSkills(); adoptErr != nil {
|
|
warnings = append(warnings, "install metadata not updated: "+adoptErr.Error())
|
|
}
|
|
}
|
|
walk := s.skillsWalk()
|
|
allSkills, ignoreStats, err = ssync.DiscoverSourceSkillsWithStatsAndContext(s.cfg.EffectiveSkillsSource(), walk)
|
|
if err != nil {
|
|
return nil, http.StatusInternalServerError, fmt.Errorf("failed to discover skills: %w", err)
|
|
}
|
|
sourceIncomplete = walk.Follow.Incomplete()
|
|
warnings = append(warnings, ssync.SourceLinkWarnings(walk, sourceIncomplete)...)
|
|
|
|
if len(allSkills) == 0 {
|
|
warnings = append(warnings, "source directory is empty (0 skills)")
|
|
}
|
|
}
|
|
discovery := ssync.TargetDiscovery{Skills: allSkills, IgnoreStats: ignoreStats, SourceIncomplete: sourceIncomplete}
|
|
if kind != kindSkill {
|
|
discovery.Agents, discovery.AllAgents, discovery.AgentsAvailable = ssync.DiscoverTargetAgents(s.agentsSource())
|
|
}
|
|
kinds := []string(nil)
|
|
if kind != "" {
|
|
kinds = []string{kind}
|
|
}
|
|
executed, err := ssync.ExecuteTargets(context.Background(), s.cfg, runTargets, ssync.ExecuteOptions{
|
|
Kinds: kinds, DryRun: dryRun, Force: force, ProjectMode: s.IsProjectMode(), ProjectRoot: s.projectRoot,
|
|
AgentsSource: s.agentsSource(), Discovery: discovery, BuiltinAgentTargets: s.builtinAgentTargets(),
|
|
ResolveExtension: s.resolveExtensionSpec, DiagnosticsTargets: s.cfg.Targets,
|
|
MovedTargets: ssync.MovedProjectTargets(s.projectCfg, s.cfg.Targets),
|
|
})
|
|
if err != nil {
|
|
return nil, http.StatusInternalServerError, err
|
|
}
|
|
results = executed.Results
|
|
failed = append(failed, executed.Failed...)
|
|
unmatched = executed.Unmatched
|
|
warnings = append(warnings, executed.Warnings...)
|
|
|
|
// Log the sync operation. A target counts once however many parts failed.
|
|
failedNames := failedTargetNames(failed)
|
|
logArgs := map[string]any{
|
|
"targets_total": total,
|
|
"targets_failed": len(failedNames),
|
|
"dry_run": dryRun,
|
|
"force": force,
|
|
"kind": kind,
|
|
"scope": "ui",
|
|
}
|
|
if len(failedNames) > 0 {
|
|
logArgs["failed_targets"] = failedNames
|
|
}
|
|
if project != "" {
|
|
logArgs["project"] = project
|
|
}
|
|
status := "ok"
|
|
switch {
|
|
case len(failedNames) >= total && len(failedNames) > 0:
|
|
status = "error"
|
|
case len(failedNames) > 0:
|
|
status = "partial"
|
|
}
|
|
s.writeOpsLog("sync", status, start, logArgs, "")
|
|
|
|
return &syncOutcome{results: results, warnings: warnings, unmatched: unmatched, failed: failed, folderConflicts: executed.FolderConflicts, pathOverlap: executed.PathOverlap, skills: executed.Skills, ignoreStats: executed.IgnoreStats, allAgents: executed.AllAgents}, 0, nil
|
|
}
|
|
|
|
// failedTargetNames returns the distinct targets in failed, sorted.
|
|
func failedTargetNames(failed []syncFailure) []string {
|
|
names := make([]string, 0, len(failed))
|
|
for _, f := range failed {
|
|
names = append(names, f.Target)
|
|
}
|
|
slices.Sort(names)
|
|
return slices.Compact(names)
|
|
}
|
|
|
|
// backupBeforeSync snapshots the target folders a sync may overwrite, as the
|
|
// CLI does, then trims old snapshots. Project mode backs up agents only, like
|
|
// `sync -p`. Failures come back as warnings. Callers must hold s.mu.
|
|
func (s *Server) backupBeforeSync(targets map[string]config.TargetConfig, skills, agents bool) []string {
|
|
return ssync.BackupTargets(targets, skills, agents, ssync.BackupTargetsOptions{
|
|
Dir: s.backupDir(), Retention: s.backupRetention(), ProjectMode: s.IsProjectMode(), ProjectRoot: s.projectRoot,
|
|
BuiltinAgentTargets: s.builtinAgentTargets(),
|
|
})
|
|
}
|
|
|
|
func (s *Server) computeContextCost(skills []ssync.DiscoveredSkill) map[string]any {
|
|
type tokenPair struct{ always, onDemand int }
|
|
groupMap := make(map[tokenPair][]string)
|
|
|
|
type skillToken struct {
|
|
name string
|
|
descTokens int
|
|
bodyTokens int
|
|
}
|
|
|
|
var maxAlways, maxOnDemand int
|
|
var worstAlwaysSkills, worstOnDemandSkills []skillToken
|
|
var worstAlwaysTarget, worstOnDemandTarget string
|
|
|
|
cfgMode := s.cfg.Mode
|
|
if cfgMode == "" {
|
|
cfgMode = "merge"
|
|
}
|
|
|
|
for name, target := range s.cfg.Targets {
|
|
filtered, fErr := ssync.TargetSkills(name, target, cfgMode, s.cfg.EffectiveSkillsSource(), skills)
|
|
if fErr != nil {
|
|
filtered = skills
|
|
}
|
|
|
|
var at, ot int
|
|
var perSkill []skillToken
|
|
for _, sk := range filtered {
|
|
at += sk.DescTokens
|
|
ot += sk.BodyTokens
|
|
perSkill = append(perSkill, skillToken{
|
|
name: sk.FlatName,
|
|
descTokens: sk.DescTokens,
|
|
bodyTokens: sk.BodyTokens,
|
|
})
|
|
}
|
|
|
|
groupMap[tokenPair{at, ot}] = append(groupMap[tokenPair{at, ot}], name)
|
|
|
|
if at > maxAlways {
|
|
maxAlways = at
|
|
worstAlwaysSkills = perSkill
|
|
worstAlwaysTarget = name
|
|
} else if at > 0 && at == maxAlways && name < worstAlwaysTarget {
|
|
worstAlwaysTarget = name
|
|
worstAlwaysSkills = perSkill
|
|
}
|
|
if ot > maxOnDemand {
|
|
maxOnDemand = ot
|
|
worstOnDemandSkills = perSkill
|
|
worstOnDemandTarget = name
|
|
} else if ot > 0 && ot == maxOnDemand && name < worstOnDemandTarget {
|
|
worstOnDemandTarget = name
|
|
worstOnDemandSkills = perSkill
|
|
}
|
|
}
|
|
|
|
type group struct {
|
|
Targets []string `json:"targets"`
|
|
AlwaysLoadedTokens int `json:"always_loaded_tokens"`
|
|
OnDemandTokens int `json:"on_demand_tokens"`
|
|
}
|
|
|
|
groups := make([]group, 0, len(groupMap))
|
|
for pair, names := range groupMap {
|
|
sort.Strings(names)
|
|
groups = append(groups, group{
|
|
Targets: names,
|
|
AlwaysLoadedTokens: pair.always,
|
|
OnDemandTokens: pair.onDemand,
|
|
})
|
|
}
|
|
sort.Slice(groups, func(i, j int) bool { return groups[i].Targets[0] < groups[j].Targets[0] })
|
|
|
|
budget := s.cfg.ContextBudget
|
|
if s.IsProjectMode() && s.projectCfg != nil {
|
|
budget = s.projectCfg.ContextBudget
|
|
}
|
|
|
|
result := map[string]any{"groups": groups}
|
|
|
|
type offender struct {
|
|
Name string `json:"name"`
|
|
Tokens int `json:"tokens"`
|
|
}
|
|
type warning struct {
|
|
Type string `json:"type"`
|
|
Target string `json:"target"`
|
|
Actual int `json:"actual"`
|
|
Budget int `json:"budget"`
|
|
TopOffenders []offender `json:"top_offenders"`
|
|
}
|
|
|
|
topN := func(perSkill []skillToken, n int, byDesc bool) []offender {
|
|
type pair struct {
|
|
name string
|
|
tokens int
|
|
}
|
|
pairs := make([]pair, 0, len(perSkill))
|
|
for _, sk := range perSkill {
|
|
t := sk.bodyTokens
|
|
if byDesc {
|
|
t = sk.descTokens
|
|
}
|
|
if t > 0 {
|
|
pairs = append(pairs, pair{sk.name, t})
|
|
}
|
|
}
|
|
sort.Slice(pairs, func(i, j int) bool { return pairs[i].tokens > pairs[j].tokens })
|
|
if len(pairs) > n {
|
|
pairs = pairs[:n]
|
|
}
|
|
out := make([]offender, len(pairs))
|
|
for i, p := range pairs {
|
|
out[i] = offender{Name: p.name, Tokens: p.tokens}
|
|
}
|
|
return out
|
|
}
|
|
|
|
var warns []warning
|
|
if t := budget.AlwaysLoadedThreshold(); t > 0 && maxAlways > t {
|
|
warns = append(warns, warning{
|
|
Type: "always_loaded", Target: worstAlwaysTarget,
|
|
Actual: maxAlways, Budget: t,
|
|
TopOffenders: topN(worstAlwaysSkills, 3, true),
|
|
})
|
|
}
|
|
if t := budget.OnDemandThreshold(); t > 0 && maxOnDemand > t {
|
|
warns = append(warns, warning{
|
|
Type: "on_demand", Target: worstOnDemandTarget,
|
|
Actual: maxOnDemand, Budget: t,
|
|
TopOffenders: topN(worstOnDemandSkills, 3, false),
|
|
})
|
|
}
|
|
if len(warns) > 0 {
|
|
result["warnings"] = warns
|
|
}
|
|
return result
|
|
}
|
|
|
|
type diffItem struct {
|
|
Skill string `json:"skill"`
|
|
Action string `json:"action"` // "link", "update", "skip", "prune", "local", "kept" (the skill stays at a legacy entry; force changes nothing)
|
|
Reason string `json:"reason"` // human-readable description
|
|
Kind string `json:"kind,omitempty"`
|
|
}
|
|
|
|
type diffTarget struct {
|
|
Target string `json:"target"`
|
|
Items []diffItem `json:"items"`
|
|
SkippedCount int `json:"skippedCount,omitempty"`
|
|
CollisionCount int `json:"collisionCount,omitempty"`
|
|
// NamingSkippedCount is how many of SkippedCount break naming rules rather than collide.
|
|
NamingSkippedCount int `json:"namingSkippedCount,omitempty"`
|
|
}
|
|
|
|
func (s *Server) handleDiff(w http.ResponseWriter, r *http.Request) {
|
|
// Snapshot config under RLock, then release before slow I/O.
|
|
s.mu.RLock()
|
|
source := s.cfg.EffectiveSkillsSource()
|
|
agentsSource := s.agentsSource()
|
|
globalMode := s.cfg.Mode
|
|
ignorePatterns := ssync.EffectiveFileIgnorePatterns(s.cfg.Ignore)
|
|
targets := s.cloneTargets()
|
|
conflicts, _ := folderConflicts(targets, s.IsProjectMode(), globalMode, nil)
|
|
s.mu.RUnlock()
|
|
|
|
if globalMode == "" {
|
|
globalMode = "merge"
|
|
}
|
|
|
|
filterTarget := r.URL.Query().Get("target")
|
|
|
|
discovered, ignoreStats, err := ssync.DiscoverSourceSkillsWithStats(source, s.skillsWalk())
|
|
if err != nil {
|
|
writeError(w, http.StatusInternalServerError, err.Error())
|
|
return
|
|
}
|
|
|
|
diffs := make([]diffTarget, 0)
|
|
for name, target := range targets {
|
|
if filterTarget != "" && filterTarget != name {
|
|
continue
|
|
}
|
|
diffs = append(diffs, s.computeTargetDiff(name, target, discovered, globalMode, source, ignorePatterns))
|
|
}
|
|
|
|
diffs = s.appendAgentDiffs(diffs, targets, agentsSource, filterTarget)
|
|
|
|
resp := map[string]any{"diffs": diffs, "folder_conflicts": conflicts}
|
|
maps.Copy(resp, ignorePayload(ignoreStats))
|
|
maps.Copy(resp, agentIgnorePayload(agentsSource, nil))
|
|
writeJSON(w, resp)
|
|
}
|