Files
skillshare/tests/integration/extras_test.go
T
Willie b62faeed60 fix(sync): skip extras whose source directory is missing
Global sync created a missing extras source, project sync and `sync
--all` skipped it, and the Web API created it while ignoring any
MkdirAll error. Creating an empty source only hides a misconfigured path,
so every caller now skips the extra and tells the user to create the
directory. The Web API reports the hint in a new per-extra "warnings"
field; existing response fields are unchanged.
2026-09-30 02:05:34 +08:00

1495 lines
49 KiB
Go

//go:build !online
package integration
import (
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"skillshare/internal/testutil"
)
// TestExtras_Init_Global verifies that "extras init" creates the source directory
// and persists the extra entry in the global config.
func TestExtras_Init_Global(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Need at least a minimal config so config.Load() succeeds.
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "Created extras/rules/")
// Verify source directory was created under extras/
sourceDir := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
if _, err := os.Stat(sourceDir); os.IsNotExist(err) {
t.Errorf("expected extras source dir %s to exist", sourceDir)
}
// Verify config.yaml now contains extras section
configContent := sb.ReadFile(sb.ConfigPath)
if !strings.Contains(configContent, "extras:") {
t.Errorf("expected config to contain 'extras:', got:\n%s", configContent)
}
if !strings.Contains(configContent, "rules") {
t.Errorf("expected config to contain 'rules', got:\n%s", configContent)
}
}
// TestExtras_Init_InvalidName verifies that names with invalid characters are rejected.
func TestExtras_Init_InvalidName(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
result := sb.RunCLI("extras", "init", "../bad", "--target", "/tmp/x", "-g")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "invalid")
}
// TestExtras_Init_ReservedName verifies that reserved names (e.g. "skills") are rejected.
func TestExtras_Init_ReservedName(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
result := sb.RunCLI("extras", "init", "skills", "--target", "/tmp/x", "-g")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "reserved")
}
// TestExtras_List_Empty verifies that "extras list" reports nothing when no extras are configured.
func TestExtras_List_Empty(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
result := sb.RunCLI("extras", "list", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "No extras configured")
}
// TestExtras_List_WithExtras verifies that "extras list" shows extra name and file count.
func TestExtras_List_WithExtras(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
// Create extras source directory with files.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
os.WriteFile(filepath.Join(rulesSource, "testing.md"), []byte("# Testing"), 0644)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("extras", "list", "-g")
result.AssertSuccess(t)
// Header and extra name should be present.
result.AssertAnyOutputContains(t, "Extras")
result.AssertAnyOutputContains(t, "rules")
// File count should be shown in the source line.
result.AssertAnyOutputContains(t, "2 files")
}
// TestExtras_Remove verifies that "extras remove --force" removes the entry from config
// while leaving source files intact.
func TestExtras_Remove(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
// Create extras source with a file.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("extras", "remove", "rules", "--force", "-g")
result.AssertSuccess(t)
// Config should no longer contain the extras entry.
configContent := sb.ReadFile(sb.ConfigPath)
if strings.Contains(configContent, "name: rules") {
t.Errorf("expected config to no longer contain 'name: rules', got:\n%s", configContent)
}
// Source files should still exist.
sourceFile := filepath.Join(rulesSource, "coding.md")
if !sb.FileExists(sourceFile) {
t.Error("source file should be preserved after remove")
}
}
// TestExtras_SyncExtras_Global verifies that "sync extras" syncs files from the
// extras source directory into the configured target.
func TestExtras_SyncExtras_Global(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create extras source with files.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("sync", "extras", "-g")
result.AssertSuccess(t)
// Header should show "Syncing extras"
result.AssertAnyOutputContains(t, "Syncing extras")
// Sync verb or file count should appear
result.AssertAnyOutputContains(t, "synced")
// Verify file was symlinked into target.
codingLink := filepath.Join(rulesTarget, "coding.md")
if !sb.IsSymlink(codingLink) {
t.Error("coding.md should be a symlink in target after sync")
}
}
// TestExtras_Init_Duplicate verifies that initialising an extra with an already-used
// name is rejected.
func TestExtras_Init_Duplicate(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
// Config already has an extra named "rules".
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "already exists")
}
// TestExtras_Init_Force_Global verifies that "extras init --force" overwrites
// an existing extra in global mode.
func TestExtras_Init_Force_Global(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
oldTarget := filepath.Join(sb.Home, ".claude", "rules")
newTarget := filepath.Join(sb.Home, ".cursor", "rules")
os.MkdirAll(oldTarget, 0755)
os.MkdirAll(newTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
// Config already has an extra named "rules" pointing to oldTarget.
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + oldTarget + `
`)
// Re-init with --force and a different target.
result := sb.RunCLI("extras", "init", "rules", "--target", newTarget, "--force", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "Created extras/rules/")
// Config should contain the new target, not the old one.
configContent := sb.ReadFile(sb.ConfigPath)
if !strings.Contains(configContent, newTarget) {
t.Errorf("expected config to contain new target %s, got:\n%s", newTarget, configContent)
}
if strings.Contains(configContent, oldTarget) {
t.Errorf("expected config to NOT contain old target %s, got:\n%s", oldTarget, configContent)
}
}
// TestExtras_Init_Force_Project verifies that "extras init --force -p" overwrites
// an existing extra in project mode.
func TestExtras_Init_Force_Project(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
projectRoot := sb.SetupProjectDir("claude")
oldTarget := filepath.Join(projectRoot, ".claude", "rules")
newTarget := filepath.Join(projectRoot, ".claude", "prompts")
os.MkdirAll(oldTarget, 0755)
os.MkdirAll(newTarget, 0755)
// Project config already has an extra named "rules".
sb.WriteProjectConfig(projectRoot, `targets:
- claude
extras:
- name: rules
targets:
- path: `+oldTarget+`
`)
// Re-init with --force and a different target.
result := sb.RunCLIInDir(projectRoot, "extras", "init", "rules", "--target", newTarget, "--force", "-p")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "Created .skillshare/extras/rules/")
// Project config should contain the new target, not the old one.
projConfigPath := filepath.Join(projectRoot, ".skillshare", "config.yaml")
configContent := sb.ReadFile(projConfigPath)
if !strings.Contains(configContent, newTarget) {
t.Errorf("expected project config to contain new target %s, got:\n%s", newTarget, configContent)
}
if strings.Contains(configContent, oldTarget) {
t.Errorf("expected project config to NOT contain old target %s, got:\n%s", oldTarget, configContent)
}
}
// TestExtras_Init_SourceNotSupportedInProjectMode verifies that --source is
// rejected in project mode with a clear error message.
func TestExtras_Init_ProjectSourceMustBeRelative(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
projectRoot := sb.SetupProjectDir("claude")
target := filepath.Join(projectRoot, ".claude", "rules")
os.MkdirAll(target, 0755)
result := sb.RunCLIInDir(projectRoot, "extras", "init", "rules",
"--target", target,
"--source", "/some/custom/path",
"-p")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "must be relative to the project root")
}
// TestExtras_Source_Show verifies that "extras source" shows the current extras_source.
func TestExtras_Source_Show(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
customExtras := filepath.Join(sb.Home, "custom-extras")
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
extras_source: ` + customExtras + `
targets:
claude:
path: ` + claudeTarget + `
`)
result := sb.RunCLI("extras", "source", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "extras_source:")
result.AssertAnyOutputContains(t, "custom-extras")
}
// TestExtras_Source_ShowDefault verifies that "extras source" shows the default
// path when extras_source is not explicitly set.
func TestExtras_Source_ShowDefault(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
result := sb.RunCLI("extras", "source", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "(default)")
}
// TestExtras_Source_Set verifies that "extras source <path>" updates extras_source
// in the global config.
func TestExtras_Source_Set(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
newExtras := filepath.Join(sb.Home, "new-extras")
result := sb.RunCLI("extras", "source", newExtras, "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "Set extras_source")
// Verify config was updated
configContent := sb.ReadFile(sb.ConfigPath)
if !strings.Contains(configContent, newExtras) {
t.Errorf("expected config to contain %s, got:\n%s", newExtras, configContent)
}
}
// TestExtras_Source_ProjectModeRejected verifies that "extras source -p" is rejected.
func TestExtras_Source_ProjectModeRejected(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
projectRoot := sb.SetupProjectDir("claude")
result := sb.RunCLIInDir(projectRoot, "extras", "source", "-p")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "not supported in project mode")
}
// TestExtras_Collect verifies that "extras collect" moves local (non-symlink) files
// from a target directory into the extras source and replaces them with symlinks.
func TestExtras_Collect(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create extras source directory.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
// Create target directory with a local (non-symlink) file.
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
localFile := filepath.Join(rulesTarget, "local-rule.md")
os.WriteFile(localFile, []byte("# Local Rule"), 0644)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("extras", "collect", "rules", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "collected")
// File should now exist in source.
sourceFile := filepath.Join(rulesSource, "local-rule.md")
if !sb.FileExists(sourceFile) {
t.Error("collected file should exist in extras source directory")
}
// Original location should now be a symlink.
if !sb.IsSymlink(localFile) {
t.Error("original file should be replaced with a symlink after collect")
}
// Symlink should point to the source file.
if got := sb.SymlinkTarget(localFile); got != sourceFile {
t.Errorf("symlink target = %q, want %q", got, sourceFile)
}
}
// TestExtras_Collect_DryRun verifies that "extras collect --dry-run" reports what
// would be collected without actually moving any files.
func TestExtras_Collect_DryRun(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create extras source directory.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
// Create target directory with a local file.
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
localFile := filepath.Join(rulesTarget, "dry-rule.md")
os.WriteFile(localFile, []byte("# Dry Rule"), 0644)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("extras", "collect", "rules", "--dry-run", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "would collect")
// File should NOT have been moved to source.
sourceFile := filepath.Join(rulesSource, "dry-rule.md")
if sb.FileExists(sourceFile) {
t.Error("dry run should not move file to source")
}
// Original file should still be a regular file, not a symlink.
if sb.IsSymlink(localFile) {
t.Error("dry run should not replace file with symlink")
}
}
// TestExtras_Collect_ForceCopyMode verifies that "extras collect --force" pulls
// target edits back over an existing source file, and that copy-mode targets
// keep regular files instead of becoming symlinks.
func TestExtras_Collect_ForceCopyMode(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
sourceFile := filepath.Join(rulesSource, "rule.md")
os.WriteFile(sourceFile, []byte("# Old"), 0644)
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
localFile := filepath.Join(rulesTarget, "rule.md")
os.WriteFile(localFile, []byte("# Edited in target"), 0644)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
mode: copy
`)
// Trailing slash: --from must still match the configured copy-mode target.
result := sb.RunCLI("extras", "collect", "rules", "--from", rulesTarget+"/", "--force", "-g")
result.AssertSuccess(t)
if got := sb.ReadFile(sourceFile); got != "# Edited in target" {
t.Errorf("source content = %q, want target edit", got)
}
if sb.IsSymlink(localFile) {
t.Error("copy-mode target should stay a regular file after collect")
}
}
// TestExtras_Status verifies that "status" shows extras information when extras are configured.
func TestExtras_Status(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create extras source with files.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
os.WriteFile(filepath.Join(rulesSource, "testing.md"), []byte("# Testing"), 0644)
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("status", "-g")
result.AssertSuccess(t)
// Status should show an "Extras" section.
result.AssertAnyOutputContains(t, "Extras")
// Should report file count and target path.
result.AssertAnyOutputContains(t, "2 files")
result.AssertAnyOutputContains(t, rulesTarget)
}
// TestExtras_DiffExtras verifies that "diff" automatically shows extras that need syncing.
func TestExtras_DiffExtras(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create extras source with a file.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "pending.md"), []byte("# Pending"), 0644)
// Create target directory but do NOT sync yet.
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("diff", "--no-tui", "-g")
result.AssertSuccess(t)
// Output should show the extras diff section.
result.AssertAnyOutputContains(t, "Extras")
// Should indicate file needs syncing.
result.AssertAnyOutputContains(t, "pending.md")
}
// TestExtras_SyncExtras_JSON verifies that "sync extras --json" produces valid JSON
// output with an extras array.
func TestExtras_SyncExtras_JSON(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create extras source with a file.
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("sync", "extras", "--json", "-g")
result.AssertSuccess(t)
// Verify JSON structure.
if !strings.Contains(result.Stdout, `"extras"`) {
t.Errorf("expected JSON to contain 'extras' key, got:\n%s", result.Stdout)
}
if !strings.Contains(result.Stdout, `"rules"`) {
t.Errorf("expected JSON to contain 'rules' entry, got:\n%s", result.Stdout)
}
if !strings.Contains(result.Stdout, `"duration"`) {
t.Errorf("expected JSON to contain 'duration' key, got:\n%s", result.Stdout)
}
}
// TestExtras_SyncAll_Project verifies that "sync --all -p" syncs both skills and extras
// in project mode.
func TestExtras_SyncAll_Project(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Set up a project directory with a claude target.
projectRoot := sb.SetupProjectDir("claude")
// Create a project skill.
sb.CreateProjectSkill(projectRoot, "proj-skill", map[string]string{
"SKILL.md": "# Project Skill",
})
// Create project extras source.
extrasSource := filepath.Join(projectRoot, ".skillshare", "extras", "rules")
os.MkdirAll(extrasSource, 0755)
os.WriteFile(filepath.Join(extrasSource, "proj-rule.md"), []byte("# Project Rule"), 0644)
// Create extras target directory.
extrasTarget := filepath.Join(projectRoot, ".claude", "rules")
os.MkdirAll(extrasTarget, 0755)
// Write project config with both skills target and extras using absolute path.
sb.WriteProjectConfig(projectRoot, `targets:
- claude
extras:
- name: rules
targets:
- path: `+extrasTarget+`
`)
result := sb.RunCLIInDir(projectRoot, "sync", "--all", "-p")
result.AssertSuccess(t)
// Verify extras were synced (symlink created in target).
ruleLink := filepath.Join(extrasTarget, "proj-rule.md")
if !sb.IsSymlink(ruleLink) {
t.Errorf("project extras should be synced as symlink after sync --all -p\nstdout: %s\nstderr: %s",
result.Stdout, result.Stderr)
}
}
// TestExtras_Doctor verifies that "doctor" reports a missing extras source directory as an error.
func TestExtras_Doctor(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
// Config references extras "rules" but we do NOT create the source directory.
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("doctor", "-g")
result.AssertSuccess(t)
// Doctor should report the missing extras source.
result.AssertAnyOutputContains(t, "rules")
result.AssertAnyOutputContains(t, "missing")
}
// TestExtras_Migration verifies that "sync extras" migrates a legacy flat extras directory
// (configDir/name/) to the new location (configDir/extras/name/).
func TestExtras_Migration(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Create the OLD-style (legacy) directory: configDir/rules/ (not extras/rules/).
configDir := filepath.Join(sb.Home, ".config", "skillshare")
legacySource := filepath.Join(configDir, "rules")
os.MkdirAll(legacySource, 0755)
os.WriteFile(filepath.Join(legacySource, "legacy.md"), []byte("# Legacy Rule"), 0644)
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("sync", "extras", "-g")
result.AssertSuccess(t)
// After migration, the new location should exist and legacy should be gone.
newSource := filepath.Join(configDir, "extras", "rules")
if _, err := os.Stat(newSource); os.IsNotExist(err) {
t.Errorf("expected migrated directory at %s to exist", newSource)
}
if _, err := os.Stat(legacySource); err == nil {
t.Errorf("expected legacy directory %s to be removed after migration", legacySource)
}
// The file should be accessible from the new location.
migratedFile := filepath.Join(newSource, "legacy.md")
if !sb.FileExists(migratedFile) {
t.Error("migrated file should exist in new extras directory")
}
// File should be synced as symlink in target.
ruleLink := filepath.Join(rulesTarget, "legacy.md")
if !sb.IsSymlink(ruleLink) {
t.Error("migrated file should be synced as symlink in target")
}
}
// TestExtras_Mode_SingleTarget verifies that "extras mode" changes the sync mode
// of an extra's target when the extra has only one target (auto-resolved).
func TestExtras_Mode_SingleTarget(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
os.WriteFile(filepath.Join(rulesSource, "coding.md"), []byte("# Coding"), 0644)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
// Change mode from merge (default) to copy
result := sb.RunCLI("extras", "rules", "--mode", "copy", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "copy")
// Verify config was updated
configContent := sb.ReadFile(sb.ConfigPath)
if !strings.Contains(configContent, "mode: copy") {
t.Errorf("expected config to contain 'mode: copy', got:\n%s", configContent)
}
}
// TestExtras_Mode_Shorthand verifies the shorthand form:
// "extras <name> --mode <mode>" (without the "mode" subcommand).
func TestExtras_Mode_Shorthand(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
// Use shorthand: extras rules --mode symlink
result := sb.RunCLI("extras", "rules", "--mode", "symlink", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "symlink")
configContent := sb.ReadFile(sb.ConfigPath)
if !strings.Contains(configContent, "mode: symlink") {
t.Errorf("expected config to contain 'mode: symlink', got:\n%s", configContent)
}
}
// TestExtras_Mode_WithTarget verifies that "extras <name> --mode" with --target
// changes the mode on a specific target when multiple targets exist.
func TestExtras_Mode_WithTarget(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget1 := filepath.Join(sb.Home, ".claude", "rules")
rulesTarget2 := filepath.Join(sb.Home, ".cursor", "rules")
os.MkdirAll(rulesTarget1, 0755)
os.MkdirAll(rulesTarget2, 0755)
rulesSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(rulesSource, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget1 + `
- path: ` + rulesTarget2 + `
`)
// Change mode of second target only
result := sb.RunCLI("extras", "rules", "--target", rulesTarget2, "--mode", "copy", "-g")
result.AssertSuccess(t)
configContent := sb.ReadFile(sb.ConfigPath)
// The second target should have mode: copy, first should remain default (merge)
if !strings.Contains(configContent, "mode: copy") {
t.Errorf("expected config to contain 'mode: copy' for second target, got:\n%s", configContent)
}
}
// TestExtras_Mode_MultipleTargets_NoTarget verifies that "extras <name> --mode" errors
// when the extra has multiple targets and --target is not specified.
func TestExtras_Mode_MultipleTargets_NoTarget(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget1 := filepath.Join(sb.Home, ".claude", "rules")
rulesTarget2 := filepath.Join(sb.Home, ".cursor", "rules")
os.MkdirAll(rulesTarget1, 0755)
os.MkdirAll(rulesTarget2, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget1 + `
- path: ` + rulesTarget2 + `
`)
result := sb.RunCLI("extras", "rules", "--mode", "copy", "-g")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "--target")
}
// TestExtras_Mode_InvalidMode verifies that an invalid mode is rejected.
func TestExtras_Mode_InvalidMode(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
extras:
- name: rules
targets:
- path: ` + rulesTarget + `
`)
result := sb.RunCLI("extras", "rules", "--mode", "invalid", "-g")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "invalid")
}
// TestExtras_Mode_UnknownExtra verifies that mode change on non-existent extra fails.
func TestExtras_Mode_UnknownExtra(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
sb.WriteConfig(`source: ` + sb.SourcePath + `
targets:
claude:
path: ` + claudeTarget + `
`)
result := sb.RunCLI("extras", "nonexistent", "--mode", "copy", "-g")
result.AssertFailure(t)
result.AssertAnyOutputContains(t, "not found")
}
// TestInit_WritesSourcesMap verifies that fresh "init" emits the new
// `sources:` map (v0.19.16+) with skills and agents entries, and does NOT
// write the legacy top-level source / agents_source / extras_source fields.
// The extras parent directory is provided at runtime by
// Config.EffectiveExtrasSource() — it does not need to be persisted.
func TestInit_WritesSourcesMap(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Remove config file to simulate fresh state
os.Remove(sb.ConfigPath)
// Run a fully non-interactive init
result := sb.RunCLI("init", "--no-copy", "--no-targets", "--no-git", "--no-skill")
result.AssertSuccess(t)
configContent := sb.ReadFile(sb.ConfigPath)
// New format: must contain `sources:` map with skills/agents entries.
if !strings.Contains(configContent, "sources:") {
t.Errorf("expected config to contain 'sources:' map, got:\n%s", configContent)
}
if !strings.Contains(configContent, "skills: "+sb.SourcePath) {
t.Errorf("expected sources.skills to point to %s, got:\n%s", sb.SourcePath, configContent)
}
expectedAgents := filepath.Join(filepath.Dir(sb.SourcePath), "agents")
if !strings.Contains(configContent, "agents: "+expectedAgents) {
t.Errorf("expected sources.agents to point to %s, got:\n%s", expectedAgents, configContent)
}
// Legacy fields must NOT be written by fresh init.
if strings.Contains(configContent, "\nsource:") {
t.Errorf("expected no legacy 'source:' field, got:\n%s", configContent)
}
if strings.Contains(configContent, "extras_source:") {
t.Errorf("expected no legacy 'extras_source:' field, got:\n%s", configContent)
}
if strings.Contains(configContent, "agents_source:") {
t.Errorf("expected no legacy 'agents_source:' field, got:\n%s", configContent)
}
}
// TestExtrasInit_PreservesEmptyExtrasSource verifies that "extras init" does
// NOT silently backfill the legacy extras_source field when it was absent.
// Config.EffectiveExtrasSource() handles the runtime fallback, so writing the
// derived path into the user's config would surprise them with an unexpected
// diff. The extras source directory must still be created on disk.
func TestExtrasInit_PreservesEmptyExtrasSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
// Write config WITHOUT extras_source
sb.WriteConfig(fmt.Sprintf("source: %s\ntargets:\n claude:\n path: %s",
sb.SourcePath, claudeTarget))
// Verify extras_source is absent before
configBefore := sb.ReadFile(sb.ConfigPath)
if strings.Contains(configBefore, "extras_source:") {
t.Fatalf("precondition: expected no extras_source, got:\n%s", configBefore)
}
// Run extras init
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
result.AssertSuccess(t)
// Verify extras_source was NOT silently backfilled.
configAfter := sb.ReadFile(sb.ConfigPath)
if strings.Contains(configAfter, "extras_source:") {
t.Errorf("expected no extras_source backfill, got:\n%s", configAfter)
}
// But the derived extras source directory must still exist on disk so
// the new extra has somewhere to live.
expected := filepath.Join(filepath.Dir(sb.SourcePath), "extras", "rules")
if _, err := os.Stat(expected); err != nil {
t.Errorf("expected extras source directory %s to exist: %v", expected, err)
}
}
// TestExtrasInit_WithExtrasSource verifies that when extras_source is set in config,
// "extras init" creates the source dir under the custom extras_source path.
func TestExtrasInit_WithExtrasSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
customExtras := filepath.Join(sb.Home, "custom-extras")
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
sb.WriteConfig("source: " + sb.SourcePath + "\nextras_source: " + customExtras + "\ntargets:\n claude:\n path: " + claudeTarget)
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
result.AssertSuccess(t)
// Source directory should be created under extras_source, not the default location.
rulesDir := filepath.Join(customExtras, "rules")
if _, err := os.Stat(rulesDir); os.IsNotExist(err) {
t.Errorf("expected extras source dir at %s\nstdout: %s\nstderr: %s", rulesDir, result.Stdout, result.Stderr)
}
// The default location should NOT have been created.
defaultDir := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
if _, err := os.Stat(defaultDir); err == nil {
t.Errorf("default extras dir %s should not exist when extras_source is set", defaultDir)
}
}
// TestExtrasInit_WithPerExtraSource verifies that --source flag writes the per-extra
// source path to config and creates the source directory at that location.
func TestExtrasInit_WithPerExtraSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
customSource := filepath.Join(sb.Home, "my-rules")
os.MkdirAll(customSource, 0o755)
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets:\n claude:\n path: " + claudeTarget)
result := sb.RunCLI("extras", "init", "rules",
"--target", rulesTarget,
"--source", customSource,
"-g")
result.AssertSuccess(t)
// Config should contain the per-extra source path.
configContent := sb.ReadFile(sb.ConfigPath)
if !strings.Contains(configContent, customSource) {
t.Errorf("expected config to contain source %s, got:\n%s", customSource, configContent)
}
}
// TestExtrasList_SourceType verifies JSON output includes correct source_type
// for per-extra source overrides.
func TestExtrasList_SourceType(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
customSource := filepath.Join(sb.Home, "my-rules")
os.MkdirAll(customSource, 0o755)
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
sb.WriteConfig("source: " + sb.SourcePath + "\ntargets:\n claude:\n path: " + claudeTarget + "\nextras:\n - name: rules\n source: " + customSource + "\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("extras", "list", "--json", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "per-extra")
}
// TestExtrasSourcePriority verifies the 3-level source resolution priority chain:
// per-extra source > extras_source > default.
func TestExtrasSourcePriority(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
perExtra := filepath.Join(sb.Home, "per-extra-rules")
globalExtras := filepath.Join(sb.Home, "global-extras")
os.MkdirAll(perExtra, 0o755)
os.MkdirAll(filepath.Join(globalExtras, "commands"), 0o755)
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
commandsTarget := filepath.Join(sb.Home, ".claude", "commands")
os.MkdirAll(rulesTarget, 0o755)
os.MkdirAll(commandsTarget, 0o755)
sb.WriteConfig("source: " + sb.SourcePath +
"\nextras_source: " + globalExtras +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n source: " + perExtra +
"\n targets:\n - path: " + rulesTarget +
"\n - name: commands\n targets:\n - path: " + commandsTarget)
result := sb.RunCLI("extras", "list", "--json", "-g")
result.AssertSuccess(t)
// "rules" has per-extra source → source_type should be "per-extra"
result.AssertAnyOutputContains(t, "per-extra")
// "commands" falls back to extras_source → source_type should be "extras_source"
result.AssertAnyOutputContains(t, "extras_source")
}
// TestExtrasList_DefaultSourceType verifies that "extras list --json" shows
// source_type "default" when neither extras_source nor per-extra source is set.
func TestExtrasList_DefaultSourceType(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
// Create default extras source directory with a file so it reports as existing.
defaultSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
os.MkdirAll(defaultSource, 0o755)
os.WriteFile(filepath.Join(defaultSource, "coding.md"), []byte("# Coding"), 0o644)
// Config with extras but NO extras_source and NO per-extra source.
sb.WriteConfig("source: " + sb.SourcePath +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("extras", "list", "--json", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, `"source_type"`)
result.AssertAnyOutputContains(t, `"default"`)
}
// TestExtrasSync_WithPerExtraSource verifies that sync uses the per-extra source path
// instead of the default location.
func TestExtrasSync_WithPerExtraSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
// Create a custom source directory with a file.
customSource := filepath.Join(sb.Home, "my-rules")
os.MkdirAll(customSource, 0o755)
os.WriteFile(filepath.Join(customSource, "custom.md"), []byte("# Custom Rule"), 0o644)
// Create target directory.
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
// Config with per-extra source pointing to custom location.
sb.WriteConfig("source: " + sb.SourcePath +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n source: " + customSource +
"\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("sync", "extras", "-g")
result.AssertSuccess(t)
// Verify symlink was created in target.
customLink := filepath.Join(rulesTarget, "custom.md")
if !sb.IsSymlink(customLink) {
t.Errorf("custom.md should be a symlink in target after sync\nstdout: %s\nstderr: %s",
result.Stdout, result.Stderr)
}
// Verify symlink points to the custom source, not the default.
expectedTarget := filepath.Join(customSource, "custom.md")
if got := sb.SymlinkTarget(customLink); got != expectedTarget {
t.Errorf("symlink target = %q, want %q", got, expectedTarget)
}
}
// TestExtrasSync_WithExtrasSource verifies that sync uses extras_source when set.
func TestExtrasSync_WithExtrasSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
// Create custom extras_source directory with the extra's subdirectory.
globalExtras := filepath.Join(sb.Home, "custom-extras")
rulesSource := filepath.Join(globalExtras, "rules")
os.MkdirAll(rulesSource, 0o755)
os.WriteFile(filepath.Join(rulesSource, "global-extra.md"), []byte("# Global Extra"), 0o644)
// Create target directory.
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
// Config with extras_source set (no per-extra source).
sb.WriteConfig("source: " + sb.SourcePath +
"\nextras_source: " + globalExtras +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("sync", "extras", "-g")
result.AssertSuccess(t)
// Verify symlink was created from the extras_source location.
link := filepath.Join(rulesTarget, "global-extra.md")
if !sb.IsSymlink(link) {
t.Errorf("global-extra.md should be a symlink after sync\nstdout: %s\nstderr: %s",
result.Stdout, result.Stderr)
}
expectedTarget := filepath.Join(rulesSource, "global-extra.md")
if got := sb.SymlinkTarget(link); got != expectedTarget {
t.Errorf("symlink target = %q, want %q", got, expectedTarget)
}
}
// TestExtrasCollect_WithPerExtraSource verifies that collect moves files into
// the per-extra source directory, not the default location.
func TestExtrasCollect_WithPerExtraSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
// Create empty custom source directory.
customSource := filepath.Join(sb.Home, "my-rules")
os.MkdirAll(customSource, 0o755)
// Create target directory with a real (non-symlink) file.
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
localFile := filepath.Join(rulesTarget, "local-rule.md")
os.WriteFile(localFile, []byte("# Local Rule"), 0o644)
// Config with per-extra source.
sb.WriteConfig("source: " + sb.SourcePath +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n source: " + customSource +
"\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("extras", "collect", "rules", "-g")
result.AssertSuccess(t)
result.AssertAnyOutputContains(t, "collected")
// File should now exist in the custom source, not the default.
collectedFile := filepath.Join(customSource, "local-rule.md")
if !sb.FileExists(collectedFile) {
t.Errorf("collected file should exist in custom source %s", customSource)
}
// Default source location should NOT have the file.
defaultSource := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules", "local-rule.md")
if sb.FileExists(defaultSource) {
t.Error("file should NOT be collected to the default source when per-extra source is set")
}
// Original location should now be a symlink pointing to custom source.
if !sb.IsSymlink(localFile) {
t.Error("original file should be replaced with a symlink after collect")
}
if got := sb.SymlinkTarget(localFile); got != collectedFile {
t.Errorf("symlink target = %q, want %q", got, collectedFile)
}
}
// TestExtrasDoctor_WithCustomSource verifies that doctor reports the correct
// custom source path when per-extra source is configured.
func TestExtrasDoctor_WithCustomSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
// Config with per-extra source pointing to a non-existent directory.
nonExistentSource := filepath.Join(sb.Home, "does-not-exist-rules")
sb.WriteConfig("source: " + sb.SourcePath +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n source: " + nonExistentSource +
"\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("doctor", "-g")
result.AssertSuccess(t)
// Doctor should mention the custom path in its extras check.
result.AssertAnyOutputContains(t, "rules")
result.AssertAnyOutputContains(t, "missing")
}
// TestExtrasRemove_WithPerExtraSource verifies that remove works correctly
// when per-extra source is configured.
func TestExtrasRemove_WithPerExtraSource(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0o755)
// Create custom source directory with a file.
customSource := filepath.Join(sb.Home, "my-rules")
os.MkdirAll(customSource, 0o755)
os.WriteFile(filepath.Join(customSource, "coding.md"), []byte("# Coding"), 0o644)
// Config with per-extra source.
sb.WriteConfig("source: " + sb.SourcePath +
"\ntargets:\n claude:\n path: " + claudeTarget +
"\nextras:\n - name: rules\n source: " + customSource +
"\n targets:\n - path: " + rulesTarget)
result := sb.RunCLI("extras", "remove", "rules", "--force", "-g")
result.AssertSuccess(t)
// Config should no longer contain the extras entry.
configContent := sb.ReadFile(sb.ConfigPath)
if strings.Contains(configContent, "name: rules") {
t.Errorf("expected config to no longer contain 'name: rules', got:\n%s", configContent)
}
// Source files should still exist (remove only removes from config).
if !sb.FileExists(filepath.Join(customSource, "coding.md")) {
t.Error("source file in custom path should be preserved after remove")
}
}
// TestExtrasSync_SkipsMissingSourceDir verifies that "sync extras" skips an
// extra whose source directory does not exist, with a hint, instead of
// creating it.
func TestExtrasSync_SkipsMissingSourceDir(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
// Set extras_source to a non-existent directory
customExtras := filepath.Join(sb.Home, "new-extras-dir")
// Don't create it — sync should skip the extra
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
os.MkdirAll(rulesTarget, 0755)
sb.WriteConfig(fmt.Sprintf("source: %s\nextras_source: %s\ntargets:\n claude:\n path: %s\nextras:\n - name: rules\n targets:\n - path: %s",
sb.SourcePath, customExtras, claudeTarget, rulesTarget))
result := sb.RunCLI("sync", "extras", "-g")
result.AssertSuccess(t)
// Verify source dir was not created
rulesDir := filepath.Join(customExtras, "rules")
if _, err := os.Stat(rulesDir); !os.IsNotExist(err) {
t.Errorf("sync must not create source dir at %s, stat err = %v", rulesDir, err)
}
// Verify output explains the skip
result.AssertAnyOutputContains(t, "Source directory does not exist")
result.AssertAnyOutputContains(t, "Create it to start syncing rules")
}
// TestExtrasInit_WithExtrasSource_AutoCreatesDir verifies that "extras init"
// creates the source directory under extras_source even if the extras_source
// directory itself doesn't exist yet.
func TestExtrasInit_WithExtrasSource_AutoCreatesDir(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
claudeTarget := sb.CreateTarget("claude")
rulesTarget := filepath.Join(sb.Home, ".claude", "rules")
// extras_source points to a path where parent exists but extras_source itself doesn't.
customExtras := filepath.Join(sb.Home, "brand-new-extras")
// Intentionally do NOT create customExtras — init should create it.
sb.WriteConfig("source: " + sb.SourcePath +
"\nextras_source: " + customExtras +
"\ntargets:\n claude:\n path: " + claudeTarget)
result := sb.RunCLI("extras", "init", "rules", "--target", rulesTarget, "-g")
result.AssertSuccess(t)
// The directory should have been auto-created at extras_source/rules.
rulesDir := filepath.Join(customExtras, "rules")
if _, err := os.Stat(rulesDir); os.IsNotExist(err) {
t.Errorf("expected extras source dir at %s to be auto-created\nstdout: %s\nstderr: %s",
rulesDir, result.Stdout, result.Stderr)
}
// The default location should NOT have been created.
defaultDir := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
if _, err := os.Stat(defaultDir); err == nil {
t.Errorf("default extras dir %s should not exist when extras_source is set", defaultDir)
}
}
// Identical local files are kept; only differing files need --force.
func TestExtrasSyncPreservedLocalMessage(t *testing.T) {
for _, content := range []string{"same", "different"} {
t.Run(content, func(t *testing.T) {
sb := testutil.NewSandbox(t)
defer sb.Cleanup()
source := filepath.Join(sb.Home, ".config", "skillshare", "extras", "rules")
target := filepath.Join(sb.Home, ".claude", "rules")
for _, path := range []string{source, target} {
if err := os.MkdirAll(path, 0755); err != nil {
t.Fatal(err)
}
}
if err := os.WriteFile(filepath.Join(source, "a.md"), []byte("same"), 0644); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(target, "a.md"), []byte(content), 0644); err != nil {
t.Fatal(err)
}
sb.WriteConfig("source: " + sb.SourcePath + "\nextras:\n - name: rules\n targets:\n - path: " + target + "\n mode: merge\n")
result := sb.RunCLI("sync", "extras", "-g")
result.AssertSuccess(t)
if content == "same" {
result.AssertAnyOutputContains(t, "1 local preserved")
if strings.Contains(result.Stdout+result.Stderr, "use --force") {
t.Fatal(result.Stdout + result.Stderr)
}
} else {
result.AssertAnyOutputContains(t, "1 files skipped (use --force to override)")
}
if got := sb.ReadFile(filepath.Join(target, "a.md")); got != content {
t.Fatalf("local file changed: %q", got)
}
})
}
}