feat: add local skill store and targets

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
+}

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")
+	}
+}

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))
+}

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,
+	}
+}

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")
+	}
+}