mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
Add global project list, show, add, edit, sync and remove so setup scripts can register repositories without editing YAML or opening the dashboard. Keep dry runs read-only and report completed work when a target fails. Reuse the shared project service and sync runners. Include command docs, translations, completions and regression coverage. Quote overlap hints for their shell and log partial project syncs consistently with ordinary sync.
455 lines
14 KiB
Go
455 lines
14 KiB
Go
package server
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"fmt"
|
|
"maps"
|
|
"net/http"
|
|
"slices"
|
|
"sort"
|
|
"time"
|
|
|
|
"skillshare/internal/config"
|
|
"skillshare/internal/projects"
|
|
"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(), nil))
|
|
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
|
|
}
|
|
|
|
// 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.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}, 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)
|
|
}
|