mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
Both tools now document ~/.agents/skills and <project>/.agents/skills as their skills locations and keep the old directories only for backward compatibility. Writing to the old path next to `universal` makes them read every skill from two places. Global configs pin absolute paths, so they are unaffected and keep their overlap warning. Project configs store target names only, so an existing project follows the new default on its next sync while the links it created in .goose/skills or .openhands/skills would stay behind and show up as duplicates. Project sync now removes those leftovers from also_scans directories that no configured target writes to. That directory belongs to another tool, so the cleanup runs the prune with ManagedOnly: only symlinks into the source and manifest-tracked folders are removed. The flat-name heuristic would otherwise delete hand-made folders such as `_drafts`. Targets with an explicit path are skipped, and --dry-run only previews. Refs #135
1312 lines
39 KiB
Go
1312 lines
39 KiB
Go
//go:build !online
|
|
|
|
package integration
|
|
|
|
import (
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"skillshare/internal/testutil"
|
|
)
|
|
|
|
func TestInit_Fresh_CreatesConfigAndSource(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove config file to simulate fresh state
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with input to skip interactive prompts
|
|
// Input: "2" to start fresh, "n" to skip adding other targets, "n" to skip git, "n" to skip skill
|
|
result := sb.RunCLIWithInput("2\nn\nn\nn\n", "init")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Initialized successfully")
|
|
|
|
// Verify config was created
|
|
if !sb.FileExists(sb.ConfigPath) {
|
|
t.Error("config file should be created")
|
|
}
|
|
|
|
// Verify source directory was created
|
|
if !sb.FileExists(sb.SourcePath) {
|
|
t.Error("source directory should be created")
|
|
}
|
|
|
|
cfg := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(cfg, "__pycache__/") {
|
|
t.Errorf("config should include default __pycache__/ ignore, got:\n%s", cfg)
|
|
}
|
|
}
|
|
|
|
func TestInit_WithSourceFlag_UsesCustomPath(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove config file
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
customSource := filepath.Join(sb.Home, "my-skills")
|
|
|
|
// Input: "1" to start fresh (no skills detected), "n" to skip git, "n" to skip skill
|
|
result := sb.RunCLIWithInput("1\nn\nn\n", "init", "--source", customSource)
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, customSource)
|
|
|
|
// Verify custom source was created
|
|
if !sb.FileExists(customSource) {
|
|
t.Error("custom source directory should be created")
|
|
}
|
|
}
|
|
|
|
func TestInit_DryRun_DoesNotWrite(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
os.RemoveAll(sb.SourcePath)
|
|
|
|
result := sb.RunCLIWithInput("n\nn\n", "init", "--dry-run")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Dry run")
|
|
|
|
if sb.FileExists(sb.ConfigPath) {
|
|
t.Error("dry-run should not create config")
|
|
}
|
|
|
|
if sb.FileExists(sb.SourcePath) {
|
|
t.Error("dry-run should not create source directory")
|
|
}
|
|
|
|
defaultSkillPath := filepath.Join(sb.SourcePath, "skillshare", "SKILL.md")
|
|
if sb.FileExists(defaultSkillPath) {
|
|
t.Error("dry-run should not create default skill")
|
|
}
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_ReturnsError(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create config to simulate already initialized
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
result := sb.RunCLI("init")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "already initialized")
|
|
}
|
|
|
|
func TestInit_CreatesDefaultSkill(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove config file
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Use flags for reliability (survey MultiSelect doesn't work well in non-TTY stdin)
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify default skillshare skill was created
|
|
defaultSkillPath := filepath.Join(sb.SourcePath, "skillshare", "SKILL.md")
|
|
if !sb.FileExists(defaultSkillPath) {
|
|
t.Error("default skillshare skill should be created")
|
|
}
|
|
}
|
|
|
|
func TestInit_DetectsCLI_OffersImport(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove config file
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create existing claude skills directory with a skill
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
testSkillPath := filepath.Join(claudeSkillsPath, "test-skill")
|
|
os.MkdirAll(testSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(testSkillPath, "SKILL.md"), []byte("# Test"), 0644)
|
|
|
|
// Input: "2" to start fresh (not copy), "y" to add claude as target, "n" to skip git, "n" to skip skill
|
|
result := sb.RunCLIWithInput("2\ny\nn\nn\n", "init")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "claude")
|
|
}
|
|
|
|
func TestInit_WithSkills_CopiesOnConfirm(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove config file
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create existing claude skills directory with a skill
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
testSkillPath := filepath.Join(claudeSkillsPath, "my-test-skill")
|
|
os.MkdirAll(testSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(testSkillPath, "SKILL.md"), []byte("# My Test Skill"), 0644)
|
|
|
|
// Input: "1" to copy from claude, "n" to skip git, "n" to skip skill
|
|
result := sb.RunCLIWithInput("1\nn\nn\n", "init")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Copy")
|
|
|
|
// Check if skill was copied to source
|
|
copiedSkillPath := filepath.Join(sb.SourcePath, "my-test-skill", "SKILL.md")
|
|
if !sb.FileExists(copiedSkillPath) {
|
|
t.Error("skill should be copied to source")
|
|
}
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_RemoteFlag_AddsRemote(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create config to simulate already initialized
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Initialize git in source directory
|
|
cmd := exec.Command("git", "init")
|
|
cmd.Dir = sb.SourcePath
|
|
if err := cmd.Run(); err != nil {
|
|
t.Skip("git not available")
|
|
}
|
|
|
|
// Run init with --remote on already initialized setup
|
|
result := sb.RunCLI("init", "--remote", "git@github.com:test/skills.git")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Git remote configured")
|
|
|
|
// Verify remote was added
|
|
cmd = exec.Command("git", "remote", "-v")
|
|
cmd.Dir = sb.SourcePath
|
|
output, err := cmd.Output()
|
|
if err != nil {
|
|
t.Errorf("failed to check git remote: %v", err)
|
|
}
|
|
if !strings.Contains(string(output), "git@github.com:test/skills.git") {
|
|
t.Errorf("remote should be configured, got: %s", output)
|
|
}
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_RemoteFlag_DryRun(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Initialize git in source directory
|
|
cmd := exec.Command("git", "init")
|
|
cmd.Dir = sb.SourcePath
|
|
if err := cmd.Run(); err != nil {
|
|
t.Skip("git not available")
|
|
}
|
|
|
|
result := sb.RunCLI("init", "--remote", "git@github.com:test/skills.git", "--dry-run")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Would add git remote")
|
|
|
|
// Verify remote was NOT added
|
|
cmd = exec.Command("git", "remote", "-v")
|
|
cmd.Dir = sb.SourcePath
|
|
output, _ := cmd.Output()
|
|
if strings.Contains(string(output), "github.com") {
|
|
t.Error("dry-run should not add remote")
|
|
}
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_RemoteFlag_AlreadyExists(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Initialize git with existing remote
|
|
cmd := exec.Command("git", "init")
|
|
cmd.Dir = sb.SourcePath
|
|
if err := cmd.Run(); err != nil {
|
|
t.Skip("git not available")
|
|
}
|
|
|
|
cmd = exec.Command("git", "remote", "add", "origin", "git@github.com:existing/repo.git")
|
|
cmd.Dir = sb.SourcePath
|
|
cmd.Run()
|
|
|
|
// Try to add different remote
|
|
result := sb.RunCLI("init", "--remote", "git@github.com:new/repo.git")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "already exists")
|
|
result.AssertOutputContains(t, "git remote set-url")
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_RemoteFlag_SameRemote(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Initialize git with existing remote
|
|
cmd := exec.Command("git", "init")
|
|
cmd.Dir = sb.SourcePath
|
|
if err := cmd.Run(); err != nil {
|
|
t.Skip("git not available")
|
|
}
|
|
|
|
cmd = exec.Command("git", "remote", "add", "origin", "git@github.com:test/skills.git")
|
|
cmd.Dir = sb.SourcePath
|
|
cmd.Run()
|
|
|
|
// Try to add same remote
|
|
result := sb.RunCLI("init", "--remote", "git@github.com:test/skills.git")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "already configured")
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_RemoteFlag_NoGit_AutoInitsGit(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Config exists but git is NOT initialized (simulates second machine setup)
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
result := sb.RunCLI("init", "--remote", "git@github.com:test/skills.git")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Git remote configured")
|
|
|
|
// Verify git was initialized
|
|
gitDir := filepath.Join(sb.SourcePath, ".git")
|
|
if _, err := os.Stat(gitDir); os.IsNotExist(err) {
|
|
t.Error("git should have been auto-initialized")
|
|
}
|
|
|
|
// Verify remote was added
|
|
cmd := exec.Command("git", "remote", "-v")
|
|
cmd.Dir = sb.SourcePath
|
|
output, err := cmd.Output()
|
|
if err != nil {
|
|
t.Errorf("failed to check git remote: %v", err)
|
|
}
|
|
if !strings.Contains(string(output), "git@github.com:test/skills.git") {
|
|
t.Errorf("remote should be configured, got: %s", output)
|
|
}
|
|
}
|
|
|
|
func TestInit_AlreadyInitialized_RemoteFlag_WithNoGit_DoesNotCreateCommit(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Initialize git repo and create initial commit.
|
|
cmd := exec.Command("git", "init")
|
|
cmd.Dir = sb.SourcePath
|
|
if err := cmd.Run(); err != nil {
|
|
t.Skip("git not available")
|
|
}
|
|
testutil.RunGit(t, sb.SourcePath, "config", "user.email", "test@example.com")
|
|
testutil.RunGit(t, sb.SourcePath, "config", "user.name", "Test User")
|
|
|
|
seedDir := filepath.Join(sb.SourcePath, "seed-skill")
|
|
if err := os.MkdirAll(seedDir, 0o755); err != nil {
|
|
t.Fatalf("failed to create seed skill dir: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(seedDir, "SKILL.md"), []byte("# Seed"), 0o644); err != nil {
|
|
t.Fatalf("failed to write seed SKILL.md: %v", err)
|
|
}
|
|
testutil.RunGit(t, sb.SourcePath, "add", "-A")
|
|
testutil.RunGit(t, sb.SourcePath, "commit", "-m", "initial")
|
|
beforeHead := testutil.RunGit(t, sb.SourcePath, "rev-parse", "HEAD")
|
|
|
|
// Add dirty file that should remain uncommitted when --no-git is used.
|
|
dirtyDir := filepath.Join(sb.SourcePath, "dirty-skill")
|
|
if err := os.MkdirAll(dirtyDir, 0o755); err != nil {
|
|
t.Fatalf("failed to create dirty skill dir: %v", err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dirtyDir, "SKILL.md"), []byte("# Dirty"), 0o644); err != nil {
|
|
t.Fatalf("failed to write dirty SKILL.md: %v", err)
|
|
}
|
|
|
|
result := sb.RunCLI("init", "--remote", "git@github.com:test/skills.git", "--no-git")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "--no-git")
|
|
|
|
afterHead := testutil.RunGit(t, sb.SourcePath, "rev-parse", "HEAD")
|
|
if beforeHead != afterHead {
|
|
t.Fatalf("expected no new commit with --no-git, before=%s after=%s", beforeHead, afterHead)
|
|
}
|
|
|
|
status := testutil.RunGit(t, sb.SourcePath, "status", "--porcelain")
|
|
if !strings.Contains(status, "dirty-skill") {
|
|
t.Fatalf("expected dirty file to remain uncommitted, got status: %s", status)
|
|
}
|
|
}
|
|
|
|
// ============================================
|
|
// Non-interactive flag tests
|
|
// ============================================
|
|
|
|
func TestInit_NoCopy_StartsEmpty(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create existing skills directory
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
testSkillPath := filepath.Join(claudeSkillsPath, "my-skill")
|
|
os.MkdirAll(testSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(testSkillPath, "SKILL.md"), []byte("# Test"), 0644)
|
|
|
|
// Run init with --no-copy and --no-targets to skip prompts
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "--no-copy")
|
|
|
|
// Verify skill was NOT copied (only skillshare skill should exist)
|
|
copiedSkillPath := filepath.Join(sb.SourcePath, "my-skill")
|
|
if sb.FileExists(copiedSkillPath) {
|
|
t.Error("skill should NOT be copied when using --no-copy")
|
|
}
|
|
}
|
|
|
|
func TestInit_CopyFromByName(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create existing claude skills directory with a skill
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
testSkillPath := filepath.Join(claudeSkillsPath, "copy-test-skill")
|
|
os.MkdirAll(testSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(testSkillPath, "SKILL.md"), []byte("# Copy Test"), 0644)
|
|
|
|
// Run init with --copy-from claude
|
|
result := sb.RunCLI("init", "--copy-from", "claude", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "matched by name")
|
|
|
|
// Verify skill was copied
|
|
copiedSkillPath := filepath.Join(sb.SourcePath, "copy-test-skill", "SKILL.md")
|
|
if !sb.FileExists(copiedSkillPath) {
|
|
t.Error("skill should be copied when using --copy-from claude")
|
|
}
|
|
}
|
|
|
|
func TestInit_CopyFromByPath(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create custom skills directory
|
|
customPath := filepath.Join(sb.Home, "custom-skills")
|
|
os.MkdirAll(customPath, 0755)
|
|
testSkillPath := filepath.Join(customPath, "path-test-skill")
|
|
os.MkdirAll(testSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(testSkillPath, "SKILL.md"), []byte("# Path Test"), 0644)
|
|
|
|
// Run init with --copy-from as a path
|
|
result := sb.RunCLI("init", "--copy-from", customPath, "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify skill was copied
|
|
copiedSkillPath := filepath.Join(sb.SourcePath, "path-test-skill", "SKILL.md")
|
|
if !sb.FileExists(copiedSkillPath) {
|
|
t.Error("skill should be copied when using --copy-from with path")
|
|
}
|
|
}
|
|
|
|
func TestInit_TargetsCSV(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create both claude and cursor directories
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
cursorSkillsPath := filepath.Join(sb.Home, ".cursor", "skills")
|
|
os.MkdirAll(cursorSkillsPath, 0755)
|
|
|
|
// Run init with --targets specifying both
|
|
result := sb.RunCLI("init", "--no-copy", "--targets", "claude,cursor", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Added 2 targets")
|
|
|
|
// Verify config has both targets
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "claude:") {
|
|
t.Error("config should contain claude target")
|
|
}
|
|
if !strings.Contains(configContent, "cursor:") {
|
|
t.Error("config should contain cursor target")
|
|
}
|
|
}
|
|
|
|
func TestInit_AllTargets(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create multiple CLI directories
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
cursorSkillsPath := filepath.Join(sb.Home, ".cursor", "skills")
|
|
os.MkdirAll(cursorSkillsPath, 0755)
|
|
|
|
// Run init with --all-targets
|
|
result := sb.RunCLI("init", "--no-copy", "--all-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "--all-targets")
|
|
|
|
// Verify config has targets (including auto-detected universal)
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "claude:") || !strings.Contains(configContent, "cursor:") {
|
|
t.Errorf("config should contain all detected targets, got: %s", configContent)
|
|
}
|
|
if !strings.Contains(configContent, "universal:") {
|
|
t.Errorf("config should auto-include universal target when any CLI is detected, got: %s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_UniversalAutoDetected(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create only a claude skills directory — universal path (~/.agents/) does
|
|
// NOT exist on disk, yet init should auto-include it as a recommended target.
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
// Remove other sandbox defaults so only claude is detected
|
|
os.RemoveAll(filepath.Join(sb.Home, ".codex"))
|
|
os.RemoveAll(filepath.Join(sb.Home, ".cursor"))
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--all-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "Shared skills directory. Use this if your CLI supports ~/.agents/skills, such as Codex.")
|
|
|
|
// Verify config includes universal pointing to ~/.agents/skills
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "universal:") {
|
|
t.Errorf("config should contain universal target, got:\n%s", configContent)
|
|
}
|
|
|
|
agentsPath := filepath.Join(sb.Home, ".agents", "skills")
|
|
if !strings.Contains(configContent, agentsPath) {
|
|
t.Errorf("universal target should point to %s, got:\n%s", agentsPath, configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_Discover_UniversalAutoAdded(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Config has claude only, no universal
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
// Create a new agent directory so detectNewAgents finds something
|
|
cursorSkillsPath := filepath.Join(sb.Home, ".cursor", "skills")
|
|
os.MkdirAll(cursorSkillsPath, 0755)
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeSkillsPath + `
|
|
`)
|
|
|
|
// Run discover with --select cursor — universal should also appear as candidate
|
|
result := sb.RunCLI("init", "--discover", "--select", "cursor,universal")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify config now has both cursor and universal
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "cursor:") {
|
|
t.Errorf("config should contain cursor target, got:\n%s", configContent)
|
|
}
|
|
if !strings.Contains(configContent, "universal:") {
|
|
t.Errorf("config should contain universal target (auto-added candidate), got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_NoTargets(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create a CLI directory
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
// Run init with --no-targets
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "--no-targets")
|
|
|
|
// Verify config has empty targets
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configContent, "claude:") {
|
|
t.Error("config should NOT contain any targets when using --no-targets")
|
|
}
|
|
}
|
|
|
|
func TestInit_NoGit_SkipsGitInit(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with --no-git
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "--no-git")
|
|
|
|
// Verify .git was NOT created
|
|
gitDir := filepath.Join(sb.SourcePath, ".git")
|
|
if sb.FileExists(gitDir) {
|
|
t.Error(".git directory should NOT exist when using --no-git")
|
|
}
|
|
}
|
|
|
|
func TestInit_GitFlag_InitializesGit(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with --git
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify .git was created
|
|
gitDir := filepath.Join(sb.SourcePath, ".git")
|
|
if !sb.FileExists(gitDir) {
|
|
t.Error(".git directory should exist when using --git")
|
|
}
|
|
}
|
|
|
|
func TestInit_MutualExclusion_CopyFromAndNoCopy(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with both --copy-from and --no-copy
|
|
result := sb.RunCLI("init", "--copy-from", "claude", "--no-copy")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "mutually exclusive")
|
|
}
|
|
|
|
func TestInit_MutualExclusion_TargetsFlags(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with both --targets and --all-targets
|
|
result := sb.RunCLI("init", "--no-copy", "--targets", "claude", "--all-targets", "--no-git")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "mutually exclusive")
|
|
}
|
|
|
|
func TestInit_MutualExclusion_GitFlags(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with both --git and --no-git
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--git", "--no-git", "--no-skill")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "mutually exclusive")
|
|
}
|
|
|
|
func TestInit_FullNonInteractive(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create existing skills
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
testSkillPath := filepath.Join(claudeSkillsPath, "full-test")
|
|
os.MkdirAll(testSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(testSkillPath, "SKILL.md"), []byte("# Full Test"), 0644)
|
|
|
|
// Full non-interactive: copy from claude, all targets, with git, no skill
|
|
result := sb.RunCLI("init", "--copy-from", "claude", "--all-targets", "--git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Initialized successfully")
|
|
|
|
// Verify skill was copied
|
|
if !sb.FileExists(filepath.Join(sb.SourcePath, "full-test", "SKILL.md")) {
|
|
t.Error("skill should be copied")
|
|
}
|
|
|
|
// Verify git was initialized
|
|
if !sb.FileExists(filepath.Join(sb.SourcePath, ".git")) {
|
|
t.Error(".git should exist")
|
|
}
|
|
|
|
// Verify config has target
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "claude:") {
|
|
t.Error("config should contain claude target")
|
|
}
|
|
}
|
|
|
|
// ============================================
|
|
// Discover mode tests
|
|
// ============================================
|
|
|
|
func TestInit_AlreadyInitialized_ErrorMentionsDiscover(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create config to simulate already initialized
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
result := sb.RunCLI("init")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "--discover")
|
|
}
|
|
|
|
func TestInit_Discover_NoNewAgents(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Remove extra agent directories that sandbox creates by default
|
|
os.RemoveAll(filepath.Join(sb.Home, ".codex"))
|
|
os.RemoveAll(filepath.Join(sb.Home, ".cursor"))
|
|
|
|
// Create config with claude target (the only agent)
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeSkillsPath + `
|
|
`)
|
|
|
|
// Run discover - no new agents should be found since only claude exists and is already configured
|
|
result := sb.RunCLI("init", "--discover")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "No new agents")
|
|
}
|
|
|
|
func TestInit_Discover_DoesNotExpandSharedDirectoryTargets(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
sharedParent := filepath.Join(sb.Home, ".agents")
|
|
os.MkdirAll(sharedParent, 0755)
|
|
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
codexSkillsPath := filepath.Join(sb.Home, ".codex", "skills")
|
|
cursorSkillsPath := filepath.Join(sb.Home, ".cursor", "skills")
|
|
copilotSkillsPath := filepath.Join(sb.Home, ".copilot", "skills")
|
|
universalSkillsPath := filepath.Join(sharedParent, "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
os.MkdirAll(codexSkillsPath, 0755)
|
|
os.MkdirAll(cursorSkillsPath, 0755)
|
|
os.MkdirAll(copilotSkillsPath, 0755)
|
|
// gemini has a path of its own, so discover has at least one genuinely new
|
|
// agent to offer — codex resolves to the already-configured universal target.
|
|
os.MkdirAll(filepath.Join(sb.Home, ".gemini", "skills"), 0755)
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeSkillsPath + `
|
|
cursor:
|
|
path: ` + cursorSkillsPath + `
|
|
copilot:
|
|
path: ` + copilotSkillsPath + `
|
|
universal:
|
|
path: ` + universalSkillsPath + `
|
|
`)
|
|
|
|
result := sb.RunCLI("init", "--discover", "--select", "zed")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Agent not detected: zed")
|
|
result.AssertOutputNotContains(t, "Added 1 agent")
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configContent, "zed:") {
|
|
t.Errorf("config should not contain zed target, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_Discover_WithSelect_AddsNewAgent(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create initial config with claude only
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeSkillsPath + `
|
|
`)
|
|
|
|
// Create cursor directory (new agent)
|
|
cursorSkillsPath := filepath.Join(sb.Home, ".cursor", "skills")
|
|
os.MkdirAll(cursorSkillsPath, 0755)
|
|
|
|
// Run discover with --select
|
|
result := sb.RunCLI("init", "--discover", "--select", "cursor")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Added 1 agent")
|
|
|
|
// Verify config now has cursor
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "cursor:") {
|
|
t.Errorf("config should contain cursor target, got: %s", configContent)
|
|
}
|
|
// Should still have claude
|
|
if !strings.Contains(configContent, "claude:") {
|
|
t.Errorf("config should still contain claude target, got: %s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_Discover_WithMode_OnlyAppliesToNewTargets(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
cursorSkillsPath := filepath.Join(sb.Home, ".cursor", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
os.MkdirAll(cursorSkillsPath, 0755)
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
mode: merge
|
|
targets:
|
|
claude:
|
|
path: ` + claudeSkillsPath + `
|
|
mode: symlink
|
|
`)
|
|
|
|
result := sb.RunCLI("init", "--discover", "--select", "cursor", "--mode", "copy")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Added 1 agent")
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "mode: symlink") {
|
|
t.Errorf("existing target mode should remain unchanged, got:\n%s", configContent)
|
|
}
|
|
if !strings.Contains(configContent, "cursor:") || !strings.Contains(configContent, "mode: copy") {
|
|
t.Errorf("new target should be added with mode copy, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_Discover_WithSelect_MultipleAgents(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create initial config with no targets
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Create multiple agent directories
|
|
os.MkdirAll(filepath.Join(sb.Home, ".claude", "skills"), 0755)
|
|
os.MkdirAll(filepath.Join(sb.Home, ".cursor", "skills"), 0755)
|
|
os.MkdirAll(filepath.Join(sb.Home, ".codex", "skills"), 0755)
|
|
|
|
// Run discover with --select for multiple agents
|
|
result := sb.RunCLI("init", "--discover", "--select", "claude,cursor")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Added 2 agent")
|
|
|
|
// Verify config has both
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "claude:") {
|
|
t.Error("config should contain claude target")
|
|
}
|
|
if !strings.Contains(configContent, "cursor:") {
|
|
t.Error("config should contain cursor target")
|
|
}
|
|
// Should NOT have codex (not selected)
|
|
if strings.Contains(configContent, "codex:") {
|
|
t.Error("config should NOT contain codex target")
|
|
}
|
|
}
|
|
|
|
func TestInit_Discover_DryRun(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create initial config
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Create new agent directory
|
|
os.MkdirAll(filepath.Join(sb.Home, ".cursor", "skills"), 0755)
|
|
|
|
// Run discover with --dry-run
|
|
result := sb.RunCLI("init", "--discover", "--select", "cursor", "--dry-run")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Dry run")
|
|
|
|
// Verify config was NOT modified
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if strings.Contains(configContent, "cursor:") {
|
|
t.Error("dry-run should NOT add cursor to config")
|
|
}
|
|
}
|
|
|
|
func TestInit_Select_RequiresDiscover(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init with --select but without --discover
|
|
result := sb.RunCLI("init", "--select", "cursor")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "--select requires --discover")
|
|
}
|
|
|
|
func TestInit_Discover_SkipsAlreadyConfigured(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create config with claude already
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets:
|
|
claude:
|
|
path: ` + claudeSkillsPath + `
|
|
`)
|
|
|
|
// Try to add claude again via --select
|
|
result := sb.RunCLI("init", "--discover", "--select", "claude")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "already in config")
|
|
}
|
|
|
|
func TestInit_Discover_UnknownAgent(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Create initial config
|
|
sb.WriteConfig(`source: ` + sb.SourcePath + `
|
|
targets: {}
|
|
`)
|
|
|
|
// Try to add unknown agent
|
|
result := sb.RunCLI("init", "--discover", "--select", "unknownagent")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Unknown agent")
|
|
}
|
|
|
|
func TestInit_ModeFlag_SetsDefaultMode(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--mode", "copy", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "mode: copy") {
|
|
t.Errorf("config should contain mode: copy, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_ModeFlag_Invalid(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--mode", "invalid", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "invalid --mode value")
|
|
}
|
|
|
|
// ============================================
|
|
// Skill flag tests
|
|
// ============================================
|
|
|
|
func TestInit_NoSkill_SkipsInstall(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "--no-skill")
|
|
|
|
// Verify skill was NOT installed
|
|
skillPath := filepath.Join(sb.SourcePath, "skillshare", "SKILL.md")
|
|
if sb.FileExists(skillPath) {
|
|
t.Error("skill should NOT be installed when using --no-skill")
|
|
}
|
|
}
|
|
|
|
func TestInit_SkillFlag_InstallsSkill(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
// Verify skill was installed (either downloaded or fallback)
|
|
skillPath := filepath.Join(sb.SourcePath, "skillshare", "SKILL.md")
|
|
if !sb.FileExists(skillPath) {
|
|
t.Error("skill should be installed when using --skill")
|
|
}
|
|
}
|
|
|
|
func TestInit_Fresh_ConfigHasSchemaComment(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
firstLine := strings.SplitN(configContent, "\n", 2)[0]
|
|
if !strings.HasPrefix(firstLine, "# yaml-language-server: $schema=") {
|
|
t.Errorf("config should start with schema comment, got first line: %q", firstLine)
|
|
}
|
|
}
|
|
|
|
func TestInit_SuccessMessage_ContainsSourceHint(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Tip:")
|
|
result.AssertOutputContains(t, "--source")
|
|
}
|
|
|
|
// ============================================
|
|
// --subdir flag tests (global mode only)
|
|
// ============================================
|
|
|
|
func TestInit_Subdir_SetsSourcePath(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--subdir", "skills", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Initialized successfully")
|
|
|
|
// Verify config source ends with /skills (the subdir)
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
expectedSuffix := filepath.Join("skillshare", "skills", "skills")
|
|
if !strings.Contains(configContent, expectedSuffix) {
|
|
t.Errorf("config source should end with skills/skills (subdir appended), got:\n%s", configContent)
|
|
}
|
|
|
|
// Verify subdirectory was created
|
|
subdirPath := filepath.Join(sb.SourcePath, "skills")
|
|
if !sb.FileExists(subdirPath) {
|
|
t.Error("subdir should be created inside source path")
|
|
}
|
|
}
|
|
|
|
func TestInit_Subdir_ListFindsSkillsInSubdir(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Init with --subdir
|
|
result := sb.RunCLI("init", "--subdir", "skills", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
result.AssertSuccess(t)
|
|
|
|
// Create a skill inside the subdir
|
|
subdirSkillPath := filepath.Join(sb.SourcePath, "skills", "subdir-skill")
|
|
os.MkdirAll(subdirSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(subdirSkillPath, "SKILL.md"), []byte("---\nname: subdir-skill\ndescription: test\n---\n# Test"), 0644)
|
|
|
|
// List should find the skill
|
|
listResult := sb.RunCLI("list", "--no-tui")
|
|
listResult.AssertSuccess(t)
|
|
listResult.AssertOutputContains(t, "subdir-skill")
|
|
}
|
|
|
|
func TestInit_Subdir_SyncWorksWithSubdir(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Create a claude target directory
|
|
claudeSkillsPath := filepath.Join(sb.Home, ".claude", "skills")
|
|
os.MkdirAll(claudeSkillsPath, 0755)
|
|
|
|
// Init with --subdir and a target
|
|
result := sb.RunCLI("init", "--subdir", "myskills", "--no-copy", "--targets", "claude", "--no-git", "--no-skill")
|
|
result.AssertSuccess(t)
|
|
|
|
// Create a skill inside the subdir
|
|
subdirSkillPath := filepath.Join(sb.SourcePath, "myskills", "sync-test")
|
|
os.MkdirAll(subdirSkillPath, 0755)
|
|
os.WriteFile(filepath.Join(subdirSkillPath, "SKILL.md"), []byte("---\nname: sync-test\ndescription: test\n---\n# Sync Test"), 0644)
|
|
|
|
// Sync should work
|
|
syncResult := sb.RunCLI("sync", "--no-tui")
|
|
syncResult.AssertSuccess(t)
|
|
syncResult.AssertOutputContains(t, "Sync complete")
|
|
|
|
// Verify symlink was created in target
|
|
symlinkPath := filepath.Join(claudeSkillsPath, "sync-test")
|
|
if _, err := os.Lstat(symlinkPath); os.IsNotExist(err) {
|
|
t.Error("skill symlink should be created in target after sync")
|
|
}
|
|
}
|
|
|
|
func TestInit_Subdir_ForcesGlobalModeInProjectDir(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
// Simulate a project directory with .skillshare/config.yaml
|
|
projectDir := filepath.Join(sb.Home, "myproject")
|
|
os.MkdirAll(filepath.Join(projectDir, ".skillshare"), 0755)
|
|
os.WriteFile(filepath.Join(projectDir, ".skillshare", "config.yaml"), []byte("skills: []\ntargets: {}\n"), 0644)
|
|
|
|
// Remove global config so init can run fresh
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Run init --subdir from inside the project directory
|
|
// Without the fix, this would route to project mode and fail with "unknown option"
|
|
result := sb.RunCLIInDir(projectDir, "init", "--subdir", "skills", "--no-copy", "--no-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Initialized successfully")
|
|
}
|
|
|
|
func TestInit_Subdir_DryRunDoesNotCreate(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
os.RemoveAll(sb.SourcePath)
|
|
|
|
result := sb.RunCLI("init", "--subdir", "skills", "--no-copy", "--no-targets", "--no-git", "--no-skill", "--dry-run")
|
|
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Dry run")
|
|
|
|
// Config should not exist
|
|
if sb.FileExists(sb.ConfigPath) {
|
|
t.Error("dry-run should not create config")
|
|
}
|
|
}
|
|
|
|
func TestInit_MutualExclusion_SkillFlags(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--skill", "--no-skill")
|
|
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "mutually exclusive")
|
|
}
|
|
|
|
// ============================================
|
|
// Codex shares the universal ~/.agents/skills path
|
|
// ============================================
|
|
|
|
func TestInit_CodexOnly_AddsUniversalInsteadOfCodex(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Only ~/.codex exists (created by the sandbox); Codex reads ~/.agents/skills,
|
|
// so it must be credited to the universal target, not a codex target.
|
|
os.RemoveAll(filepath.Join(sb.Home, ".claude"))
|
|
os.RemoveAll(filepath.Join(sb.Home, ".cursor"))
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--all-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "universal:") {
|
|
t.Errorf("config should contain universal target, got:\n%s", configContent)
|
|
}
|
|
if strings.Contains(configContent, "codex:") {
|
|
t.Errorf("config should not contain a separate codex target, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_CodexAndClaude_AddsClaudeAndUniversal(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
os.RemoveAll(filepath.Join(sb.Home, ".cursor"))
|
|
os.MkdirAll(filepath.Join(sb.Home, ".claude", "skills"), 0755)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--all-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
for _, want := range []string{"claude:", "universal:"} {
|
|
if !strings.Contains(configContent, want) {
|
|
t.Errorf("config should contain %s, got:\n%s", want, configContent)
|
|
}
|
|
}
|
|
if strings.Contains(configContent, "codex:") {
|
|
t.Errorf("config should not contain a separate codex target, got:\n%s", configContent)
|
|
}
|
|
}
|
|
|
|
func TestInit_TargetsCodex_UsesAgentsPath(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--targets", "codex", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
agentsPath := filepath.Join(sb.Home, ".agents", "skills")
|
|
if !strings.Contains(configContent, agentsPath) {
|
|
t.Errorf("codex target should point to %s, got:\n%s", agentsPath, configContent)
|
|
}
|
|
}
|
|
|
|
func TestSync_CodexTarget_WritesToAgentsPath(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
sb.RunCLI("init", "--no-copy", "--targets", "codex", "--no-git", "--no-skill").AssertSuccess(t)
|
|
sb.CreateSkill("codex-skill", map[string]string{"SKILL.md": "# Codex Skill"})
|
|
|
|
sb.RunCLI("sync").AssertSuccess(t)
|
|
|
|
if !sb.IsSymlink(filepath.Join(sb.Home, ".agents", "skills", "codex-skill")) {
|
|
t.Error("skill should be linked into ~/.agents/skills")
|
|
}
|
|
if sb.FileExists(filepath.Join(sb.Home, ".codex", "skills", "codex-skill")) {
|
|
t.Error("skill should not be written to the deprecated ~/.codex/skills")
|
|
}
|
|
}
|
|
|
|
func TestInit_GooseOnly_AddsUniversalInsteadOfGoose(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
os.Remove(sb.ConfigPath)
|
|
|
|
// Goose now reads ~/.agents/skills, so only ~/.config/goose identifies it
|
|
// and the detection must be credited to the universal target.
|
|
for _, dir := range []string{".claude", ".codex", ".cursor"} {
|
|
os.RemoveAll(filepath.Join(sb.Home, dir))
|
|
}
|
|
os.MkdirAll(filepath.Join(sb.Home, ".config", "goose"), 0755)
|
|
|
|
result := sb.RunCLI("init", "--no-copy", "--all-targets", "--no-git", "--no-skill")
|
|
|
|
result.AssertSuccess(t)
|
|
|
|
configContent := sb.ReadFile(sb.ConfigPath)
|
|
if !strings.Contains(configContent, "universal:") {
|
|
t.Errorf("config should contain universal target, got:\n%s", configContent)
|
|
}
|
|
if strings.Contains(configContent, "goose:") {
|
|
t.Errorf("config should not contain a separate goose target, got:\n%s", configContent)
|
|
}
|
|
}
|