1package agent
2
3import (
4 "bytes"
5 "encoding/json"
6 "os"
7 "path/filepath"
8 "runtime"
9 "slices"
10 "strings"
11 "sync"
12 "testing"
13
14 "github.com/bnema/zut/packages/agent/skills"
15)
16
17func TestSkillPinsPersistIndependentScopes(t *testing.T) {
18 t.Setenv("ZUT_HOME", t.TempDir())
19 a, b := t.TempDir(), t.TempDir()
20 for _, pin := range []struct {
21 cwd, name string
22 global bool
23 }{
24 {a, "review", false}, {a, "review", true}, {b, "other", false},
25 } {
26 if err := toggleSkillPin(pin.cwd, pin.name, pin.global); err != nil {
27 t.Fatal(err)
28 }
29 }
30 if err := toggleSkillPin(a, "review", false); err != nil {
31 t.Fatal(err)
32 }
33 pins, err := loadSkillPins(a)
34 if err != nil || len(pins.Project) != 0 || !slices.Equal(pins.Global, []string{"review"}) {
35 t.Fatalf("pins = %+v, %v", pins, err)
36 }
37 pins, err = loadSkillPins(b)
38 if err != nil || !slices.Equal(pins.Project, []string{"other"}) || !slices.Equal(pins.Global, []string{"review"}) {
39 t.Fatalf("pins = %+v, %v", pins, err)
40 }
41 info, err := os.Stat(filepath.Join(ZutHome(), skillPinsFileName))
42 if err != nil {
43 t.Fatal(err)
44 }
45 if runtime.GOOS != "windows" && info.Mode().Perm() != 0o600 {
46 t.Fatalf("mode = %o", info.Mode().Perm())
47 }
48 if entries, err := os.ReadDir(a); err != nil || len(entries) != 0 {
49 t.Fatalf("project was modified: %v, %v", entries, err)
50 }
51 // No temp files are left next to the preferences.
52 entries, err := os.ReadDir(ZutHome())
53 if err != nil || len(entries) != 1 {
54 t.Fatalf("home entries = %v, %v", entries, err)
55 }
56}
57
58func TestSkillPinsSavedSortedAndDeduplicated(t *testing.T) {
59 t.Setenv("ZUT_HOME", t.TempDir())
60 cwd := t.TempDir()
61 // A hand-edited file with duplicates and unsorted names loads normalized.
62 key, err := skillPinProject(cwd)
63 if err != nil {
64 t.Fatal(err)
65 }
66 raw, _ := json.Marshal(skillPinsFile{Global: []string{"b", "a", "b", " "}, Projects: map[string][]string{key: {"z", "a", "a"}}})
67 if err := os.WriteFile(filepath.Join(ZutHome(), skillPinsFileName), raw, 0o600); err != nil {
68 t.Fatal(err)
69 }
70 pins, err := loadSkillPins(cwd)
71 if err != nil || !slices.Equal(pins.Global, []string{"a", "b"}) || !slices.Equal(pins.Project, []string{"a", "z"}) {
72 t.Fatalf("pins = %+v, %v", pins, err)
73 }
74 if err := toggleSkillPin(cwd, "m", false); err != nil {
75 t.Fatal(err)
76 }
77 pins, _ = loadSkillPins(cwd)
78 if !slices.Equal(pins.Project, []string{"a", "m", "z"}) {
79 t.Fatalf("project = %v", pins.Project)
80 }
81 selected, warnings := pins.Resolve([]*skills.Skill{{Name: "z"}, {Name: "a"}, {Name: "b"}})
82 if len(warnings) != 1 || len(selected) != 3 || selected[0].Name != "a" || selected[1].Name != "b" || selected[2].Name != "z" {
83 t.Fatalf("selected=%v warnings=%v", selected, warnings)
84 }
85}
86
87func TestSkillPinsDirectoryAliases(t *testing.T) {
88 t.Setenv("ZUT_HOME", t.TempDir())
89 root := t.TempDir()
90 target, alias := filepath.Join(root, "target"), filepath.Join(root, "alias")
91 if err := os.Mkdir(target, 0o700); err != nil {
92 t.Fatal(err)
93 }
94 if err := os.Symlink(target, alias); err != nil {
95 t.Skipf("symlink unavailable: %v", err)
96 }
97 if err := toggleSkillPin(target, "review", false); err != nil {
98 t.Fatal(err)
99 }
100 pins, err := loadSkillPins(alias)
101 if err != nil || !slices.Equal(pins.Project, []string{"review"}) {
102 t.Fatalf("alias pins = %+v, %v", pins, err)
103 }
104}
105
106func TestSkillPinsRejectCorruptFileWithoutOverwriting(t *testing.T) {
107 for _, original := range []string{
108 `{"global":["review"],"projects":42}`, `not json`, ``, `null`, ` null `, `[]`, `["review"]`, `42`, `"review"`, `true`,
109 `{"global":["review"]} trailing`,
110 `{"global":["review"],"future":{"x":1}}`, `{"version":2,"global":[]}`, `{"projects":{},"extra":null}`,
111 } {
112 t.Setenv("ZUT_HOME", t.TempDir())
113 path := filepath.Join(ZutHome(), skillPinsFileName)
114 if err := os.WriteFile(path, []byte(original), 0o600); err != nil {
115 t.Fatal(err)
116 }
117 pins, err := loadSkillPins(t.TempDir())
118 if err == nil || len(pins.Global) != 0 {
119 t.Fatalf("%q: pins = %+v, err = %v", original, pins, err)
120 }
121 if strings.Contains(err.Error(), "review") {
122 t.Fatalf("diagnostic echoes file contents: %v", err)
123 }
124 if err := toggleSkillPin(t.TempDir(), "new", true); err == nil {
125 t.Fatal("corrupt file overwritten")
126 }
127 got, err := os.ReadFile(path)
128 if err != nil || !bytes.Equal(got, []byte(original)) {
129 t.Fatalf("file changed: %q, %v", got, err)
130 }
131 }
132}
133
134func TestSkillPinsConcurrentTogglesKeepFileValid(t *testing.T) {
135 t.Setenv("ZUT_HOME", t.TempDir())
136 cwd := t.TempDir()
137 var wg sync.WaitGroup
138 names := []string{"a", "b", "c", "d", "e", "f"}
139 for _, n := range names {
140 wg.Add(1)
141 go func() {
142 defer wg.Done()
143 if err := toggleSkillPin(cwd, n, true); err != nil {
144 t.Error(err)
145 }
146 }()
147 }
148 wg.Wait()
149 pins, err := loadSkillPins(cwd)
150 if err != nil || !slices.Equal(pins.Global, names) {
151 t.Fatalf("pins = %+v, %v", pins, err)
152 }
153}
154
155func TestPreloadSkillPinsFreshOnlyAndNoSkill(t *testing.T) {
156 t.Setenv("ZUT_HOME", t.TempDir())
157 t.Setenv("ZUT_AGENT_SKILLS", "")
158 t.Setenv("HOME", t.TempDir())
159 cwd := t.TempDir()
160 dir := filepath.Join(cwd, ".zut", "skills", "review")
161 if err := os.MkdirAll(dir, 0o700); err != nil {
162 t.Fatal(err)
163 }
164 if err := os.WriteFile(filepath.Join(dir, "SKILL.md"), []byte("---\nname: review\ndescription: Review things.\ndisable-model-invocation: true\n---\nInspect carefully.\n"), 0o600); err != nil {
165 t.Fatal(err)
166 }
167 for _, pin := range []struct {
168 name string
169 global bool
170 }{{"review", true}, {"review", false}, {"missing", false}} {
171 if err := toggleSkillPin(cwd, pin.name, pin.global); err != nil {
172 t.Fatal(err)
173 }
174 }
175 for _, tt := range []struct {
176 name string
177 fresh, disabled bool
178 }{
179 {"fresh", true, false}, {"resumed", false, false}, {"disabled", true, true},
180 } {
181 t.Run(tt.name, func(t *testing.T) {
182 var diagnostics bytes.Buffer
183 args := Args{CWD: cwd, WithSkills: true, NoSkill: tt.disabled}
184 got := preloadSkillPins(args, tt.fresh, "question", nil, &diagnostics)
185 if tt.fresh && !tt.disabled {
186 if strings.Count(got, "# Skill: review") != 1 || !strings.Contains(got, "Inspect carefully.") || !strings.HasSuffix(got, "User request:\nquestion") {
187 t.Fatal(got)
188 }
189 if !strings.Contains(diagnostics.String(), "missing") {
190 t.Fatal("missing warning")
191 }
192 } else if got != "question" || diagnostics.Len() != 0 {
193 t.Fatalf("prompt = %q, warnings = %q", got, diagnostics.String())
194 }
195 })
196 }
197}
198
199func TestPreloadSkillPinsMalformedFileWarnsAndKeepsPrompt(t *testing.T) {
200 t.Setenv("ZUT_HOME", t.TempDir())
201 if err := os.WriteFile(filepath.Join(ZutHome(), skillPinsFileName), []byte("{"), 0o600); err != nil {
202 t.Fatal(err)
203 }
204 var diagnostics bytes.Buffer
205 got := preloadSkillPins(Args{CWD: t.TempDir(), WithSkills: true}, true, "q", nil, &diagnostics)
206 if got != "q" || !strings.Contains(diagnostics.String(), "invalid") {
207 t.Fatalf("got=%q diagnostics=%q", got, diagnostics.String())
208 }
209}
210
211func TestPreloadSkillPinsUsesExtensionSkills(t *testing.T) {
212 t.Setenv("ZUT_HOME", t.TempDir())
213 t.Setenv("ZUT_AGENT_SKILLS", "")
214 t.Setenv("HOME", t.TempDir())
215 cwd := t.TempDir()
216 if err := toggleSkillPin(cwd, "ext-skill", true); err != nil {
217 t.Fatal(err)
218 }
219 bundled := []*skills.Skill{{Name: "ext-skill", Body: "from extension", Source: "extension x"}}
220 got := preloadSkillPins(Args{CWD: cwd, WithSkills: true}, true, "q", bundled, &bytes.Buffer{})
221 if !strings.Contains(got, "from extension") {
222 t.Fatal(got)
223 }
224}
225
226func TestSkillPinsSymlinkedFileIsReadableButNeverReplaced(t *testing.T) {
227 t.Setenv("ZUT_HOME", t.TempDir())
228 target := filepath.Join(t.TempDir(), "dotfiles-skill-pins.json")
229 original := []byte("{\"global\":[\"review\"]}\n")
230 if err := os.WriteFile(target, original, 0o644); err != nil {
231 t.Fatal(err)
232 }
233 link := filepath.Join(ZutHome(), skillPinsFileName)
234 if err := os.Symlink(target, link); err != nil {
235 t.Skipf("symlink unavailable: %v", err)
236 }
237 pins, err := loadSkillPins(t.TempDir())
238 if err != nil || !slices.Equal(pins.Global, []string{"review"}) {
239 t.Fatalf("read through link: %+v, %v", pins, err)
240 }
241 err = toggleSkillPin(t.TempDir(), "other", true)
242 if err == nil || !strings.Contains(err.Error(), "symbolic link") {
243 t.Fatalf("err = %v", err)
244 }
245 if info, lerr := os.Lstat(link); lerr != nil || info.Mode()&os.ModeSymlink == 0 {
246 t.Fatalf("link was replaced: %v, %v", info, lerr)
247 }
248 if got, _ := os.ReadFile(target); !bytes.Equal(got, original) {
249 t.Fatalf("target changed: %q", got)
250 }
251 entries, _ := os.ReadDir(ZutHome())
252 if len(entries) != 1 {
253 t.Fatalf("temp file left behind: %v", entries)
254 }
255}
256
257func TestSkillPinsUnknownFieldsFailClosedWithClearError(t *testing.T) {
258 t.Setenv("ZUT_HOME", t.TempDir())
259 path := filepath.Join(ZutHome(), skillPinsFileName)
260 original := []byte(`{"global":["a"],"notes":"keep me"}`)
261 if err := os.WriteFile(path, original, 0o600); err != nil {
262 t.Fatal(err)
263 }
264 _, err := loadSkillPins(t.TempDir())
265 if err == nil || !strings.Contains(err.Error(), "global") || strings.Contains(err.Error(), "keep me") {
266 t.Fatalf("err = %v", err)
267 }
268 if err := toggleSkillPin(t.TempDir(), "b", false); err == nil {
269 t.Fatal("toggle accepted unknown fields")
270 }
271 if got, _ := os.ReadFile(path); !bytes.Equal(got, original) {
272 t.Fatalf("file changed: %q", got)
273 }
274 // The documented schema still round-trips.
275 if err := os.WriteFile(path, []byte(`{"global":["a"],"projects":{"/x":["b"]}}`), 0o600); err != nil {
276 t.Fatal(err)
277 }
278 if err := toggleSkillPin(t.TempDir(), "c", true); err != nil {
279 t.Fatal(err)
280 }
281 raw, _ := os.ReadFile(path)
282 if !strings.Contains(string(raw), `"/x"`) {
283 t.Fatalf("other project pins lost: %s", raw)
284 }
285}