mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-20 20:34:19 +00:00
* feat(check): show what changed in a skill since install #622 made a hand-edited skill visible as modified and kept update from overwriting it, but there was still no way to see the edits before deciding to keep or discard them (#621). LocalChanges compares the skill's files with the hashes recorded at install, fetches the source at the recorded commit only when a recorded file changed, and diffs each file against it, so the diff shows the user's edits even after upstream moves on. A skill without a recorded commit is refused rather than diffed against HEAD, which would show upstream changes as the user's. It backs `check <name> --diff`, GET /api/resources/{name}/local-changes, and the dashboard: the Modified locally dialog on the skill page lists the diffs, and the Updates tab links a modified skill to it. update's skip hints now point at --diff. The route looks up the exact record and refuses non-local names, so a nested or ../ path cannot borrow a top-level skill's record or read outside the source. The file diff helper moved to textdiff so the CLI and server share it. * fix(install): diff local changes against the full installed commit entry.Version holds the short SHA from `rev-parse --short`. A targeted fetch needs the full SHA, so checkoutCommit fell back to fetching every branch and tag with --unshallow: viewing one edited skill could download the repository's whole history, and fail when the commit is only reachable by its full SHA. Use entry.Commit, the full SHA install records, when it is the same commit as Version; a Commit left from an older install, or a legacy record without one, falls back to Version. * test(install): keep checkout line endings when editing in LocalChanges test On Windows git checks the installed copy out with CRLF, so overwriting SKILL.md with LF content made every line differ and the expected diff failed. Edit the installed file in place, as an editor would, and compare the diff without carriage returns.
441 lines
16 KiB
Go
441 lines
16 KiB
Go
//go:build !online
|
|
|
|
package integration
|
|
|
|
import (
|
|
"context"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"skillshare/internal/testutil"
|
|
)
|
|
|
|
func TestCompletion_Bash_OutputsScript(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "bash")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "complete -F _skillshare skillshare")
|
|
for _, cmd := range []string{"sync", "install", "list", "target", "commit", "completion"} {
|
|
result.AssertOutputContains(t, cmd)
|
|
}
|
|
}
|
|
|
|
func TestCompletion_Zsh_OutputsScript(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "zsh")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "#compdef skillshare")
|
|
result.AssertOutputContains(t, "_skillshare")
|
|
}
|
|
|
|
func TestCompletion_Fish_OutputsScript(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "fish")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "complete -c skillshare")
|
|
result.AssertOutputContains(t, "__fish_skillshare_no_subcommand")
|
|
}
|
|
|
|
func TestCompletion_PowerShell_OutputsScript(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "powershell")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Register-ArgumentCompleter")
|
|
}
|
|
|
|
func TestCompletion_Nushell_OutputsScript(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "nushell")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "export extern \"skillshare\"")
|
|
}
|
|
|
|
func TestCompletion_BackupCleanupDescription(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
for _, shell := range []string{"fish", "zsh", "nushell"} {
|
|
t.Run(shell, func(t *testing.T) {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Remove old backups and abandoned incomplete directories")
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCompletion_MCPCheck_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, subcommands := range map[string]string{
|
|
"bash": "add check edit import list remove restore serve",
|
|
"zsh": "(add check edit import list remove restore serve)",
|
|
"fish": "-a 'add check edit import list remove restore serve'",
|
|
"powershell": "@{ Name = 'serve'; Desc = 'MCP serve' }",
|
|
"nushell": "[add check edit import list remove restore serve]",
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, subcommands)
|
|
result.AssertOutputContains(t, "no-dns")
|
|
result.AssertOutputContains(t, "live")
|
|
result.AssertOutputContains(t, "accept-tools")
|
|
result.AssertOutputContains(t, "timeout")
|
|
for _, flag := range []string{"tools-allow", "tools-deny"} {
|
|
result.AssertOutputContains(t, flag)
|
|
}
|
|
result.AssertOutputNotContains(t, "direct-tools")
|
|
result.AssertOutputNotContains(t, "tools-expose")
|
|
}
|
|
}
|
|
|
|
func TestCompletion_CheckDiff_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, flag := range map[string]string{
|
|
"bash": `check_flags="--json --diff `,
|
|
"zsh": "'--diff[Show changes since install]'",
|
|
"fish": "check' -l diff",
|
|
"powershell": "'check' = '--json', '--diff'",
|
|
"nushell": "--diff # Show changes since install",
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, flag)
|
|
}
|
|
}
|
|
|
|
func TestCompletion_TargetCLIFlag_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, flag := range map[string]string{
|
|
"bash": "--config-dir --cli",
|
|
"zsh": "'--cli[",
|
|
"fish": "-l cli -r",
|
|
"powershell": "'--config-dir', '--cli'",
|
|
"nushell": "--cli: string",
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, flag)
|
|
}
|
|
}
|
|
|
|
func TestCompletion_PushPullFlag_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, flag := range map[string]string{
|
|
"bash": `push_flags="--dry-run -n --pull`,
|
|
"zsh": "'--pull[",
|
|
"fish": "using_command push' -l pull",
|
|
"powershell": "'push' = '--dry-run', '-n', '--pull'",
|
|
"nushell": "--pull # Merge remote",
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, flag)
|
|
}
|
|
}
|
|
|
|
func TestCompletion_Subcommands_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, subcommands := range map[string][]string{
|
|
"bash": {
|
|
`backup_subcmds="files agents"`,
|
|
`backup_files_subcmds="list show restore"`,
|
|
`extras_subcmds="init list remove collect source memory"`,
|
|
`audit_rules_subcmds="disable enable severity reset init"`,
|
|
`ui_subcmds="start stop"`,
|
|
},
|
|
"zsh": {
|
|
"'files:Versions of single files skillshare rewrote'",
|
|
"'1:files command:(list show restore)'",
|
|
"'1:rules command:(disable enable severity reset init)'",
|
|
"'1:subcommand:(start stop)'",
|
|
},
|
|
"fish": {
|
|
"backup' -a files",
|
|
"backup files' -a 'list show restore'",
|
|
"audit rules' -a 'disable enable severity reset init'",
|
|
"ui' -a 'start stop'",
|
|
},
|
|
"powershell": {
|
|
"'backup files' = @(",
|
|
"'audit rules' = @(",
|
|
"@{ Name = 'start'; Desc = 'Start a background UI server' }",
|
|
"@{ Name = 'plugins'; Desc = 'Sync plugins' }",
|
|
},
|
|
"nushell": {
|
|
`export extern "skillshare backup files"`,
|
|
`export extern "skillshare audit rules"`,
|
|
`export extern "skillshare status"`,
|
|
`subcommand?: string@"nu-complete skillshare ui"`,
|
|
},
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
for _, s := range subcommands {
|
|
result.AssertOutputContains(t, s)
|
|
}
|
|
// Completed once, but not in the CLI: backup restore, extras mode, hub index --audit-skills.
|
|
result.AssertOutputNotContains(t, "Restore from backup")
|
|
result.AssertOutputNotContains(t, "Change sync mode or flatten")
|
|
result.AssertOutputNotContains(t, "audit-skills")
|
|
}
|
|
}
|
|
|
|
func TestCompletion_Hooks_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, subcommands := range map[string]string{
|
|
"bash": "add disable edit enable import list remove restore sync",
|
|
"zsh": "(add disable edit enable import list remove restore sync)",
|
|
"fish": "-a 'add disable edit enable import list remove restore sync'",
|
|
"powershell": "@{ Name = 'sync'; Desc = 'Hooks sync' }",
|
|
"nushell": "[add disable edit enable import list remove restore sync]",
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, subcommands)
|
|
}
|
|
}
|
|
|
|
func TestCompletion_UnsupportedShell_Errors(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "tcsh")
|
|
result.AssertFailure(t)
|
|
result.AssertAnyOutputContains(t, "unsupported shell")
|
|
}
|
|
|
|
func TestCompletion_NoArgs_ShowsUsage(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion")
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, "Usage skillshare completion")
|
|
}
|
|
|
|
func TestCompletion_Install_WritesFile(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
result := sb.RunCLI("completion", "bash", "--install")
|
|
result.AssertSuccess(t)
|
|
result.AssertAnyOutputContains(t, "installed")
|
|
|
|
destPath := filepath.Join(sb.Home, ".local", "share", "bash-completion", "completions", "skillshare")
|
|
if _, err := os.Stat(destPath); os.IsNotExist(err) {
|
|
t.Errorf("expected completion script at %s, but file does not exist", destPath)
|
|
}
|
|
|
|
assertCandidates(t, completeIn(t, "bash", "--noprofile", "--norc", "-c", `
|
|
source "$1"
|
|
COMP_WORDS=(skillshare hooks '')
|
|
COMP_CWORD=2
|
|
_skillshare
|
|
printf '%s\n' "${COMPREPLY[@]}"
|
|
`, "bash", destPath), "add", "disable", "edit", "enable", "import", "list", "remove", "restore", "sync")
|
|
assertCandidates(t, completeIn(t, "bash", "--noprofile", "--norc", "-c", `
|
|
source "$1"
|
|
COMP_WORDS=(skillshare sync '')
|
|
COMP_CWORD=2
|
|
_skillshare
|
|
printf '%s\n' "${COMPREPLY[@]}"
|
|
`, "bash", destPath), "agents", "extras", "mcp", "hooks", "plugins")
|
|
assertCandidates(t, completeIn(t, "bash", "--noprofile", "--norc", "-c", `
|
|
source "$1"
|
|
COMP_WORDS=(skillshare mcp check --)
|
|
COMP_CWORD=3
|
|
_skillshare
|
|
printf '%s\n' "${COMPREPLY[@]}"
|
|
`, "bash", destPath), "--live", "--accept-tools", "--timeout", "--no-dns")
|
|
}
|
|
|
|
// zshCapture completes a command line in an interactive zsh under zpty and prints each
|
|
// candidate compadd receives. Arguments: the fpath directory, then the command line.
|
|
const zshCapture = `zmodload zsh/zpty
|
|
zpty z zsh -f -i
|
|
zpty -w z "PS1=''; fpath=($1 \$fpath); autoload -Uz compinit; compinit -u -d $1/.zcompdump"
|
|
zpty -w z "bindkey '^I' complete-word; comppostfuncs=( exit )"
|
|
zpty -w z 'compadd () {
|
|
if [[ ${@[1,(i)(-|--)]} == *-(O|A|D)\ * ]]; then builtin compadd "$@"; return $?; fi
|
|
typeset -a __hits
|
|
builtin compadd -A __hits "$@"
|
|
local h; for h in $__hits; do print -r -- "HIT:$h"; done
|
|
}'
|
|
zpty -w z "$2"$'\t'
|
|
local line
|
|
while zpty -r z line; do
|
|
line=${line%$'\r'}
|
|
# The first candidate can share a line with the echoed input; skip the echoed definition.
|
|
[[ $line == *HIT:* && $line != *'HIT:$h'* ]] && print -r -- ${line##*HIT:}
|
|
done
|
|
zpty -d z
|
|
`
|
|
|
|
// completeIn runs a real shell and returns its candidates, one per line; it skips when
|
|
// the shell is not installed, as on most CI images.
|
|
func completeIn(t *testing.T, shell string, args ...string) []string {
|
|
t.Helper()
|
|
if _, err := exec.LookPath(shell); err != nil {
|
|
t.Skipf("%s is not installed", shell)
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
|
|
defer cancel()
|
|
cmd := exec.CommandContext(ctx, shell, args...)
|
|
cmd.Dir = t.TempDir()
|
|
out, err := cmd.CombinedOutput()
|
|
if err != nil {
|
|
t.Fatalf("%s %v: %v\n%s", shell, args, err, out)
|
|
}
|
|
var candidates []string
|
|
for _, line := range strings.Split(string(out), "\n") {
|
|
// fish prints "candidate<TAB>description".
|
|
if name, _, _ := strings.Cut(strings.TrimSpace(line), "\t"); name != "" {
|
|
candidates = append(candidates, name)
|
|
}
|
|
}
|
|
return candidates
|
|
}
|
|
|
|
func assertCandidates(t *testing.T, got []string, want ...string) {
|
|
t.Helper()
|
|
for _, w := range want {
|
|
if !slices.Contains(got, w) {
|
|
t.Errorf("missing completion %q in %q", w, got)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompletion_Fish_CompletesMCPCheck(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
result := sb.RunCLI("completion", "fish")
|
|
result.AssertSuccess(t)
|
|
script := filepath.Join(sb.Home, "skillshare.fish")
|
|
if err := os.WriteFile(script, []byte(result.Stdout), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare mcp '"), "add", "check", "edit", "import", "list", "remove", "restore")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare mcp check --'"), "--no-dns", "--live", "--accept-tools", "--timeout")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare mcp add --'"), "--url", "--target", "--sync", "--replace", "--dry-run", "--json", "--no-tui")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare backup '"), "files", "agents")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare hub index --'"), "--audit", "--full")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare extras '"), "init", "list", "remove", "collect", "source", "memory")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare extras memory '"), "init", "list", "show", "write", "delete", "instructions")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare extras memory write --'"), "--from", "--version")
|
|
assertCandidates(t, completeIn(t, "fish", "--no-config", "-c", "source "+script+"; complete -C 'skillshare trash '"), "agents", "list", "restore", "delete", "empty")
|
|
}
|
|
|
|
func TestCompletion_Zsh_CompletesMCPCheck(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
result := sb.RunCLI("completion", "zsh")
|
|
result.AssertSuccess(t)
|
|
dir := filepath.Join(sb.Home, "zsh-functions")
|
|
capture := filepath.Join(sb.Home, "capture.zsh")
|
|
if err := os.MkdirAll(dir, 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "_skillshare"), []byte(result.Stdout), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(capture, []byte(zshCapture), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
completeIn(t, "zsh", "-n", filepath.Join(dir, "_skillshare"))
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare mcp "), "add", "check", "edit", "import", "list", "remove", "restore")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare mcp check --"), "--no-dns", "--live", "--accept-tools", "--timeout")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare backup "), "files", "agents")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare backup files "), "list", "show", "restore")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare hub index --"), "--audit", "--full")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare extras "), "init", "list", "remove", "collect", "source", "memory")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare extras memory "), "init", "list", "show", "write", "delete", "instructions")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare extras memory write --"), "--from", "--version")
|
|
assertCandidates(t, completeIn(t, "zsh", "-f", capture, dir, "skillshare trash "), "agents", "list", "restore", "delete", "empty")
|
|
}
|
|
|
|
func TestCompletion_Memory_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
for shell, commands := range map[string]string{
|
|
"bash": "init list show write delete instructions",
|
|
"zsh": "(init list show write delete instructions)",
|
|
"fish": "-a 'init list show write delete instructions'",
|
|
"powershell": "'extras memory' = @(",
|
|
"nushell": "[init list show write delete instructions]",
|
|
} {
|
|
t.Run(shell, func(t *testing.T) {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
result.AssertOutputContains(t, commands)
|
|
for _, flag := range []string{"version", "search", "from", "update-mode"} {
|
|
result.AssertOutputContains(t, flag)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestCompletion_LinkUnlink_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, want := range map[string][]string{
|
|
"bash": {"uninstall link unlink", `link_flags="--name --enable`},
|
|
"zsh": {"'link:", "'unlink:", "'--enable["},
|
|
"fish": {"-a link ", "-a unlink ", "using_command link' -l enable"},
|
|
"powershell": {"Name = 'link'", "Name = 'unlink'", "'link' = '--name', '--enable'"},
|
|
"nushell": {`export extern "skillshare link"`, `export extern "skillshare unlink"`},
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
for _, s := range want {
|
|
result.AssertOutputContains(t, s)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestCompletion_Move_AllShells(t *testing.T) {
|
|
sb := testutil.NewSandbox(t)
|
|
defer sb.Cleanup()
|
|
|
|
for shell, want := range map[string][]string{
|
|
"bash": {"unlink move list", `move_flags="--dry-run -n --force -f --json`},
|
|
"zsh": {"'move:", "'--force[Accept a target name collision]'"},
|
|
"fish": {"-a move ", "using_command move' -l force"},
|
|
"powershell": {"Name = 'move'", "'move' = '--dry-run', '-n', '--force', '-f', '--json'"},
|
|
"nushell": {`export extern "skillshare move"`, "--force(-f)"},
|
|
} {
|
|
result := sb.RunCLI("completion", shell)
|
|
result.AssertSuccess(t)
|
|
for _, s := range want {
|
|
result.AssertOutputContains(t, s)
|
|
}
|
|
}
|
|
}
|