From 3636952dca4d0a3935ce0c069024175034f04be8 Mon Sep 17 00:00:00 2001 From: wdh-home <243823965@qq.com> Date: Wed, 13 May 2026 16:30:54 +0800 Subject: [PATCH] feat: add local skill store and targets --- internal/skillstore/store.go | 114 ++++++++++++++++++++++++++ internal/skillstore/store_test.go | 75 +++++++++++++++++ internal/targets/junction_windows.go | 69 ++++++++++++++++ internal/targets/targets.go | 117 +++++++++++++++++++++++++++ internal/targets/targets_test.go | 70 ++++++++++++++++ 5 files changed, 445 insertions(+) create mode 100644 internal/skillstore/store.go create mode 100644 internal/skillstore/store_test.go create mode 100644 internal/targets/junction_windows.go create mode 100644 internal/targets/targets.go create mode 100644 internal/targets/targets_test.go diff --git a/internal/skillstore/store.go b/internal/skillstore/store.go new file mode 100644 index 0000000..5351eb9 --- /dev/null +++ b/internal/skillstore/store.go @@ -0,0 +1,114 @@ +package skillstore + +import ( + "encoding/json" + "errors" + "os" + "path/filepath" + "strings" + + "sgg-ai-skill-manager/internal/domain" +) + +type Store struct { + statePath string + reposRoot string +} + +func New(statePath, reposRoot string) *Store { + return &Store{statePath: statePath, reposRoot: reposRoot} +} + +func (s *Store) Load() (domain.State, error) { + state := domain.State{Skills: []domain.SkillState{}} + raw, err := os.ReadFile(s.statePath) + if errors.Is(err, os.ErrNotExist) { + return state, nil + } + if err != nil { + return state, err + } + if strings.TrimSpace(string(raw)) == "" { + return state, nil + } + if err := json.Unmarshal(raw, &state); err != nil { + return state, err + } + if state.Skills == nil { + state.Skills = []domain.SkillState{} + } + return state, nil +} + +func (s *Store) Save(state domain.State) error { + if state.Skills == nil { + state.Skills = []domain.SkillState{} + } + if err := os.MkdirAll(filepath.Dir(s.statePath), 0o755); err != nil { + return err + } + raw, err := json.MarshalIndent(state, "", " ") + if err != nil { + return err + } + return os.WriteFile(s.statePath, append(raw, '\n'), 0o600) +} + +func (s *Store) LocalRepoPath(org, repo string) string { + return filepath.Join(s.reposRoot, org, repo) +} + +func (s *Store) SafeLocalRepoPath(org, repo string) (string, error) { + if err := validateName(org); err != nil { + return "", err + } + if err := validateName(repo); err != nil { + return "", err + } + return s.LocalRepoPath(org, repo), nil +} + +func UpsertSkill(state domain.State, skill domain.SkillState) domain.State { + for i, existing := range state.Skills { + if existing.Org == skill.Org && existing.Repo == skill.Repo { + state.Skills[i] = skill + return state + } + } + state.Skills = append(state.Skills, skill) + return state +} + +func RemoveSkill(state domain.State, org, repo string) domain.State { + next := state.Skills[:0] + for _, skill := range state.Skills { + if skill.Org == org && skill.Repo == repo { + continue + } + next = append(next, skill) + } + state.Skills = next + return state +} + +func FindSkill(state domain.State, org, repo string) (domain.SkillState, bool) { + for _, skill := range state.Skills { + if skill.Org == org && skill.Repo == repo { + return skill, true + } + } + return domain.SkillState{}, false +} + +func validateName(name string) error { + if strings.TrimSpace(name) == "" { + return errors.New("name is required") + } + if name == "." || name == ".." { + return errors.New("name cannot be . or ..") + } + if strings.ContainsAny(name, `/\`) { + return errors.New("name cannot contain path separators") + } + return nil +} diff --git a/internal/skillstore/store_test.go b/internal/skillstore/store_test.go new file mode 100644 index 0000000..91fa144 --- /dev/null +++ b/internal/skillstore/store_test.go @@ -0,0 +1,75 @@ +package skillstore + +import ( + "path/filepath" + "testing" + + "sgg-ai-skill-manager/internal/domain" +) + +func TestStoreRoundTrip(t *testing.T) { + dir := t.TempDir() + store := New(filepath.Join(dir, "state.json"), filepath.Join(dir, "repos")) + state := domain.State{ + Skills: []domain.SkillState{ + { + Org: "skills", + Repo: "demo", + LocalPath: store.LocalRepoPath("skills", "demo"), + }, + }, + } + + if err := store.Save(state); err != nil { + t.Fatalf("Save returned error: %v", err) + } + + got, err := store.Load() + if err != nil { + t.Fatalf("Load returned error: %v", err) + } + if len(got.Skills) != 1 || got.Skills[0].Repo != "demo" { + t.Fatalf("state = %+v", got) + } +} + +func TestUpsertFindAndRemoveSkill(t *testing.T) { + state := domain.State{} + first := domain.SkillState{Org: "skills", Repo: "demo", CurrentCommit: "abc"} + second := domain.SkillState{Org: "skills", Repo: "demo", CurrentCommit: "def"} + + state = UpsertSkill(state, first) + state = UpsertSkill(state, second) + + if len(state.Skills) != 1 { + t.Fatalf("skill count = %d, want 1", len(state.Skills)) + } + found, ok := FindSkill(state, "skills", "demo") + if !ok { + t.Fatal("FindSkill did not find demo") + } + if found.CurrentCommit != "def" { + t.Fatalf("CurrentCommit = %q, want def", found.CurrentCommit) + } + + state = RemoveSkill(state, "skills", "demo") + if _, ok := FindSkill(state, "skills", "demo"); ok { + t.Fatal("FindSkill found removed skill") + } +} + +func TestLocalRepoPathRejectsUnsafeNames(t *testing.T) { + dir := t.TempDir() + store := New(filepath.Join(dir, "state.json"), filepath.Join(dir, "repos")) + + if got := store.LocalRepoPath("skills", "demo"); got != filepath.Join(dir, "repos", "skills", "demo") { + t.Fatalf("LocalRepoPath = %q", got) + } + + if _, err := store.SafeLocalRepoPath("skills/evil", "demo"); err == nil { + t.Fatal("SafeLocalRepoPath accepted org with path separator") + } + if _, err := store.SafeLocalRepoPath("skills", ".."); err == nil { + t.Fatal("SafeLocalRepoPath accepted parent traversal") + } +} diff --git a/internal/targets/junction_windows.go b/internal/targets/junction_windows.go new file mode 100644 index 0000000..ea6c8e0 --- /dev/null +++ b/internal/targets/junction_windows.go @@ -0,0 +1,69 @@ +package targets + +import ( + "errors" + "fmt" + "os" + "os/exec" + "path/filepath" + "strings" +) + +func CreateJunction(linkPath, targetPath string) error { + if err := os.MkdirAll(filepath.Dir(linkPath), 0o755); err != nil { + return err + } + cmd := exec.Command("cmd.exe", "/c", "mklink", "/J", linkPath, targetPath) + out, err := cmd.CombinedOutput() + if err != nil { + return fmt.Errorf("create junction failed: %w: %s", err, strings.TrimSpace(string(out))) + } + return nil +} + +func ReadJunctionTarget(linkPath string) (string, error) { + if _, err := os.Lstat(linkPath); err != nil { + return "", err + } + target, err := os.Readlink(linkPath) + if err == nil && target != "" { + return cleanWindowsLinkTarget(target), nil + } + evaluated, evalErr := filepath.EvalSymlinks(linkPath) + if evalErr != nil { + return "", evalErr + } + if samePath(evaluated, linkPath) { + return "", errors.New("path is not a junction") + } + return evaluated, nil +} + +func RemoveJunction(linkPath string) error { + if err := os.Remove(linkPath); err == nil || errors.Is(err, os.ErrNotExist) { + return nil + } + cmd := exec.Command("cmd.exe", "/c", "rmdir", linkPath) + out, err := cmd.CombinedOutput() + if err != nil { + return fmt.Errorf("remove junction failed: %w: %s", err, strings.TrimSpace(string(out))) + } + return nil +} + +func cleanWindowsLinkTarget(target string) string { + target = strings.TrimPrefix(target, `\??\`) + return filepath.Clean(target) +} + +func samePath(left, right string) bool { + leftAbs, leftErr := filepath.Abs(cleanWindowsLinkTarget(left)) + rightAbs, rightErr := filepath.Abs(cleanWindowsLinkTarget(right)) + if leftErr == nil { + left = leftAbs + } + if rightErr == nil { + right = rightAbs + } + return strings.EqualFold(filepath.Clean(left), filepath.Clean(right)) +} diff --git a/internal/targets/targets.go b/internal/targets/targets.go new file mode 100644 index 0000000..e006762 --- /dev/null +++ b/internal/targets/targets.go @@ -0,0 +1,117 @@ +package targets + +import ( + "errors" + "fmt" + "os" + "path/filepath" + + "sgg-ai-skill-manager/internal/domain" +) + +type Target struct { + ID string + Name string + SkillsDir string +} + +type Manager struct { + Targets map[string]Target +} + +func New(targets map[string]Target) *Manager { + return &Manager{Targets: targets} +} + +func DefaultTargets(home string) map[string]Target { + return map[string]Target{ + "codex": { + ID: "codex", + Name: "Codex", + SkillsDir: filepath.Join(home, ".codex", "skills"), + }, + "claude": { + ID: "claude", + Name: "Claude", + SkillsDir: filepath.Join(home, ".claude", "skills"), + }, + } +} + +func (m *Manager) Install(skill domain.SkillState, targetID string) (domain.SkillState, error) { + target, ok := m.Targets[targetID] + if !ok { + return skill, fmt.Errorf("unknown target %s", targetID) + } + if _, err := os.Stat(skill.LocalPath); err != nil { + return skill, fmt.Errorf("local skill path is not accessible: %w", err) + } + if skill.InstalledTargets == nil { + skill.InstalledTargets = map[string]domain.InstalledTarget{} + } + if err := os.MkdirAll(target.SkillsDir, 0o755); err != nil { + return skill, err + } + linkPath := filepath.Join(target.SkillsDir, skill.Repo) + if _, err := os.Lstat(linkPath); err == nil { + actual, readErr := ReadJunctionTarget(linkPath) + if readErr == nil && samePath(actual, skill.LocalPath) { + skill.InstalledTargets[targetID] = installedTarget(linkPath, skill.LocalPath) + return skill, nil + } + return skill, fmt.Errorf("target path conflict: %s", linkPath) + } else if !errors.Is(err, os.ErrNotExist) { + return skill, err + } + if err := CreateJunction(linkPath, skill.LocalPath); err != nil { + return skill, err + } + skill.InstalledTargets[targetID] = installedTarget(linkPath, skill.LocalPath) + return skill, nil +} + +func (m *Manager) Uninstall(skill domain.SkillState, targetID string) (domain.SkillState, error) { + record, ok := skill.InstalledTargets[targetID] + if !ok { + return skill, nil + } + actual, err := ReadJunctionTarget(record.Path) + if err != nil { + return skill, fmt.Errorf("cannot verify junction target: %w", err) + } + if !samePath(actual, record.TargetPath) || !samePath(actual, skill.LocalPath) { + return skill, fmt.Errorf("junction target mismatch: %s", record.Path) + } + if err := RemoveJunction(record.Path); err != nil { + return skill, err + } + delete(skill.InstalledTargets, targetID) + return skill, nil +} + +func (m *Manager) Status(skill domain.SkillState, targetID string) string { + target, ok := m.Targets[targetID] + if !ok { + return "unknown" + } + linkPath := filepath.Join(target.SkillsDir, skill.Repo) + actual, err := ReadJunctionTarget(linkPath) + if errors.Is(err, os.ErrNotExist) { + return "not_installed" + } + if err != nil { + return "conflict" + } + if samePath(actual, skill.LocalPath) { + return "installed" + } + return "conflict" +} + +func installedTarget(linkPath, targetPath string) domain.InstalledTarget { + return domain.InstalledTarget{ + Path: linkPath, + LinkType: "junction", + TargetPath: targetPath, + } +} diff --git a/internal/targets/targets_test.go b/internal/targets/targets_test.go new file mode 100644 index 0000000..6191e4c --- /dev/null +++ b/internal/targets/targets_test.go @@ -0,0 +1,70 @@ +package targets + +import ( + "os" + "path/filepath" + "testing" + + "sgg-ai-skill-manager/internal/domain" +) + +func TestInstallCreatesJunctionAndUninstallKeepsSource(t *testing.T) { + root := t.TempDir() + source := filepath.Join(root, "repo", "demo") + if err := os.MkdirAll(source, 0o755); err != nil { + t.Fatal(err) + } + if err := os.WriteFile(filepath.Join(source, "SKILL.md"), []byte("# Demo\n"), 0o644); err != nil { + t.Fatal(err) + } + manager := New(map[string]Target{ + "codex": {ID: "codex", Name: "Codex", SkillsDir: filepath.Join(root, "codex", "skills")}, + }) + skill := domain.SkillState{Org: "skills", Repo: "demo", LocalPath: source, InstalledTargets: map[string]domain.InstalledTarget{}} + + installed, err := manager.Install(skill, "codex") + if err != nil { + t.Fatalf("Install returned error: %v", err) + } + link := filepath.Join(root, "codex", "skills", "demo") + if _, err := os.Stat(filepath.Join(link, "SKILL.md")); err != nil { + t.Fatalf("junction does not expose SKILL.md: %v", err) + } + if installed.InstalledTargets["codex"].TargetPath != source { + t.Fatalf("installed target = %+v", installed.InstalledTargets["codex"]) + } + + uninstalled, err := manager.Uninstall(installed, "codex") + if err != nil { + t.Fatalf("Uninstall returned error: %v", err) + } + if _, err := os.Stat(source); err != nil { + t.Fatalf("source should remain after uninstall: %v", err) + } + if _, err := os.Lstat(link); !os.IsNotExist(err) { + t.Fatalf("link should be removed, err=%v", err) + } + if _, ok := uninstalled.InstalledTargets["codex"]; ok { + t.Fatal("codex install record should be removed") + } +} + +func TestInstallRejectsExistingOrdinaryDirectory(t *testing.T) { + root := t.TempDir() + source := filepath.Join(root, "repo", "demo") + link := filepath.Join(root, "codex", "skills", "demo") + if err := os.MkdirAll(source, 0o755); err != nil { + t.Fatal(err) + } + if err := os.MkdirAll(link, 0o755); err != nil { + t.Fatal(err) + } + manager := New(map[string]Target{ + "codex": {ID: "codex", Name: "Codex", SkillsDir: filepath.Join(root, "codex", "skills")}, + }) + skill := domain.SkillState{Org: "skills", Repo: "demo", LocalPath: source, InstalledTargets: map[string]domain.InstalledTarget{}} + + if _, err := manager.Install(skill, "codex"); err == nil { + t.Fatal("Install returned nil error for ordinary directory conflict") + } +}