xonecas.io
64875
Mc

mini-coder / commit 55b494c

test: prune brittle and redundant coverage

xonecas2026-04-17 55b494c6d6e1bc79118be84c0da3c9823913e8f0 parent 4fa9003

14 files changed

src/agent.test.ts+23−200
@@ -90,6 +90,18 @@ const ZERO_USAGE: Usage = {
9090 cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
9191 };
9292
93+function getTextContent(
94+ content: ReadonlyArray<{ type: string; text?: string }>,
95+): string {
96+ return content
97+ .filter(
98+ (entry): entry is { type: string; text: string } =>
99+ entry.type === "text" && typeof entry.text === "string",
100+ )
101+ .map((entry) => entry.text)
102+ .join("\n");
103+}
104+
93105 function isEventType<TType extends AgentEvent["type"]>(
94106 event: AgentEvent,
95107 type: TType,
@@ -174,31 +186,6 @@ function builtinToolHandlers(
174186 // ---------------------------------------------------------------------------
175187
176188 describe("agent loop", () => {
177- test("simple text response appends assistant message", async () => {
178- faux.setResponses([fauxAssistantMessage("Hello back!")]);
179-
180- const session = createSession(db, { cwd: tmp });
181- const userMsg = makeUser("hello");
182- const turn = appendMessage(db, session.id, userMsg);
183-
184- const result = await runAgentLoop({
185- db,
186- sessionId: session.id,
187- turn,
188- model: faux.getModel(),
189- systemPrompt: "Test",
190- tools: [],
191- toolHandlers: new Map(),
192- messages: [userMsg],
193- cwd: tmp,
194- });
195-
196- expect(result.messages).toHaveLength(2);
197- expect(result.messages[1]!.role).toBe("assistant");
198- const am = result.messages[1] as AssistantMessage;
199- expect(am.stopReason).toBe("stop");
200- });
201-
202189 test("simple text response persists to DB", async () => {
203190 faux.setResponses([fauxAssistantMessage("Hello back!")]);
204191 const session = createSession(db, { cwd: tmp });
@@ -860,39 +847,6 @@ describe("agent loop", () => {
860847 }
861848 });
862849
863- test("emits tool events during tool execution", async () => {
864- faux.setResponses([
865- fauxAssistantMessage([fauxToolCall("shell", { command: "echo test" })], {
866- stopReason: "toolUse",
867- }),
868- fauxAssistantMessage("Done."),
869- ]);
870-
871- const events: AgentEvent[] = [];
872-
873- const session = createSession(db, { cwd: tmp });
874- const userMsg = makeUser("go");
875- const turn = appendMessage(db, session.id, userMsg);
876-
877- await runAgentLoop({
878- db,
879- sessionId: session.id,
880- turn,
881- model: faux.getModel(),
882- systemPrompt: "Test",
883- tools: builtinToolDefs(),
884- toolHandlers: builtinToolHandlers(),
885- messages: [userMsg],
886- cwd: tmp,
887- onEvent: (e) => events.push(e),
888- });
889-
890- const toolStarts = events.filter((e) => e.type === "tool_start");
891- const toolEnds = events.filter((e) => e.type === "tool_end");
892- expect(toolStarts).toHaveLength(1);
893- expect(toolEnds).toHaveLength(1);
894- });
895-
896850 test("emits committed assistant and tool-result events in tool-use order", async () => {
897851 faux.setResponses([
898852 fauxAssistantMessage(
@@ -1129,9 +1083,7 @@ describe("agent loop", () => {
11291083 throw new Error("Expected tool result message");
11301084 }
11311085 expect(toolResult.isError).toBe(true);
1132- expect(toolResult.content).toEqual([
1133- { type: "text", text: "Shell error: This operation was aborted" },
1134- ]);
1086+ expect(getTextContent(toolResult.content)).toContain("aborted");
11351087
11361088 const abortedEvent = expectLastEvent(events, "aborted");
11371089 expect(abortedEvent.message.stopReason).toBe("aborted");
@@ -1201,9 +1153,8 @@ describe("agent loop", () => {
12011153 throw new Error("Expected tool result message");
12021154 }
12031155 expect(toolResult.isError).toBe(true);
1204- expect(toolResult.content).toEqual([
1205- { type: "text", text: "Tool edit failed: This operation was aborted" },
1206- ]);
1156+ expect(getTextContent(toolResult.content)).toContain("edit");
1157+ expect(getTextContent(toolResult.content)).toContain("aborted");
12071158
12081159 const startIndex = events.findIndex((event) => event.type === "tool_start");
12091160 const endIndex = events.findIndex((event) => event.type === "tool_end");
@@ -1394,68 +1345,6 @@ describe("agent loop", () => {
13941345 }
13951346 });
13961347
1397- test("preserves thinking content on assistant messages", async () => {
1398- faux.setResponses([
1399- fauxAssistantMessage([
1400- fauxThinking("Need to inspect the failing test."),
1401- fauxText("Done."),
1402- ]),
1403- ]);
1404-
1405- const session = createSession(db, { cwd: tmp });
1406- const userMsg = makeUser("hello");
1407- const turn = appendMessage(db, session.id, userMsg);
1408-
1409- const result = await runAgentLoop({
1410- db,
1411- sessionId: session.id,
1412- turn,
1413- model: faux.getModel(),
1414- systemPrompt: "Test",
1415- tools: [],
1416- toolHandlers: new Map(),
1417- messages: [userMsg],
1418- cwd: tmp,
1419- });
1420-
1421- const assistant = result.messages[1];
1422- expect(assistant?.role).toBe("assistant");
1423- if (assistant?.role !== "assistant") {
1424- throw new Error("Expected assistant message");
1425- }
1426- expect(assistant.content).toContainEqual(
1427- fauxThinking("Need to inspect the failing test."),
1428- );
1429- expect(assistant.content).toContainEqual(fauxText("Done."));
1430- });
1431-
1432- test("handles LLM error gracefully", async () => {
1433- faux.setResponses([
1434- fauxAssistantMessage("", {
1435- stopReason: "error",
1436- errorMessage: "Rate limit exceeded",
1437- }),
1438- ]);
1439-
1440- const session = createSession(db, { cwd: tmp });
1441- const userMsg = makeUser("trigger error");
1442- const turn = appendMessage(db, session.id, userMsg);
1443-
1444- const result = await runAgentLoop({
1445- db,
1446- sessionId: session.id,
1447- turn,
1448- model: faux.getModel(),
1449- systemPrompt: "Test",
1450- tools: [],
1451- toolHandlers: new Map(),
1452- messages: [userMsg],
1453- cwd: tmp,
1454- });
1455-
1456- expect(result.stopReason).toBe("error");
1457- });
1458-
14591348 test("handles unknown tool name gracefully", async () => {
14601349 faux.setResponses([
14611350 fauxAssistantMessage([fauxToolCall("nonexistent_tool", { foo: "bar" })], {
@@ -1537,66 +1426,22 @@ describe("agent loop", () => {
15371426 throw new Error("Expected tool result message");
15381427 }
15391428 expect(toolResult.isError).toBe(true);
1540- expect(toolResult.content).toEqual([
1541- { type: "text", text: "Tool shell failed: kaboom" },
1542- ]);
1429+ expect(getTextContent(toolResult.content)).toContain("shell");
1430+ expect(getTextContent(toolResult.content)).toContain("kaboom");
15431431
15441432 const toolStart = expectEvent(events, "tool_start");
15451433 const toolEnd = expectEvent(events, "tool_end");
15461434 const toolResultEvent = expectEvent(events, "tool_result");
15471435
15481436 expect(toolEnd.result.isError).toBe(true);
1549- expect(toolEnd.result.content).toEqual([
1550- { type: "text", text: "Tool shell failed: kaboom" },
1551- ]);
1437+ expect(getTextContent(toolEnd.result.content)).toContain("shell");
1438+ expect(getTextContent(toolEnd.result.content)).toContain("kaboom");
15521439 expect(events.indexOf(toolStart)).toBeLessThan(events.indexOf(toolEnd));
15531440 expect(events.indexOf(toolEnd)).toBeLessThan(
15541441 events.indexOf(toolResultEvent),
15551442 );
15561443 });
15571444
1558- test("injects a todo reminder and re-prompts when pending todos remain", async () => {
1559- faux.setResponses([
1560- fauxAssistantMessage("All done."),
1561- fauxAssistantMessage("I still need to finish the pending work."),
1562- ]);
1563-
1564- const session = createSession(db, { cwd: tmp });
1565- const userMsg = makeUser("finish the task");
1566- const turn = appendMessage(db, session.id, userMsg);
1567- const messages: Message[] = [
1568- makeTodoSnapshotMessage([
1569- { content: "Run the test suite", status: "pending" },
1570- { content: "Summarize the verified changes", status: "in_progress" },
1571- ]),
1572- userMsg,
1573- ];
1574-
1575- const result = await runAgentLoop({
1576- db,
1577- sessionId: session.id,
1578- turn,
1579- model: faux.getModel(),
1580- systemPrompt: "Test",
1581- tools: builtinToolDefs(),
1582- toolHandlers: builtinToolHandlers(messages),
1583- messages,
1584- cwd: tmp,
1585- });
1586-
1587- expect(result.stopReason).toBe("stop");
1588- expect(
1589- result.messages.filter((message) => message.role === "assistant"),
1590- ).toHaveLength(2);
1591- const lastMessage = result.messages.at(-1);
1592- if (!lastMessage || lastMessage.role !== "assistant") {
1593- throw new Error("Expected a final assistant message");
1594- }
1595- expect(lastMessage.content).toEqual([
1596- { type: "text", text: "I still need to finish the pending work." },
1597- ]);
1598- });
1599-
16001445 test("wraps injected todo reminders in a system_reminder block", async () => {
16011446 const api = "todo-reminder-tag-test";
16021447 const sourceId = "todo-reminder-tag-test-source";
@@ -1680,13 +1525,10 @@ describe("agent loop", () => {
16801525
16811526 expect(reminder.content).toStartWith("<system_reminder>\n");
16821527 expect(reminder.content).toEndWith("\n</system_reminder>");
1683- expect(reminder.content).toContain(
1684- "You have pending todo items that must be completed before finishing the task:",
1685- );
1686- expect(reminder.content).toContain("- [PENDING] Run the test suite");
1687- expect(reminder.content).toContain(
1688- "- [IN_PROGRESS] Summarize the verified changes",
1689- );
1528+ expect(reminder.content).toContain("[PENDING]");
1529+ expect(reminder.content).toContain("Run the test suite");
1530+ expect(reminder.content).toContain("[IN_PROGRESS]");
1531+ expect(reminder.content).toContain("Summarize the verified changes");
16901532 } finally {
16911533 unregisterApiProviders(sourceId);
16921534 }
@@ -1724,13 +1566,6 @@ describe("agent loop", () => {
17241566 expect(
17251567 result.messages.filter((message) => message.role === "assistant"),
17261568 ).toHaveLength(2);
1727- const lastMessage = result.messages.at(-1);
1728- if (!lastMessage || lastMessage.role !== "assistant") {
1729- throw new Error("Expected a final assistant message");
1730- }
1731- expect(lastMessage.content).toEqual([
1732- { type: "text", text: "All done again." },
1733- ]);
17341569 });
17351570
17361571 test("does not re-inject the same todo reminder after a queued steering message starts a new turn", async () => {
@@ -1773,12 +1608,6 @@ describe("agent loop", () => {
17731608 (message): message is AssistantMessage => message.role === "assistant",
17741609 );
17751610 expect(assistantMessages).toHaveLength(3);
1776- expect(assistantMessages.at(-1)?.content).toEqual([
1777- {
1778- type: "text",
1779- text: "Handled steering without a duplicate reminder.",
1780- },
1781- ]);
17821611 });
17831612
17841613 test("does not re-inject the same todo reminder when the incomplete set is only reordered", async () => {
@@ -1851,12 +1680,6 @@ describe("agent loop", () => {
18511680 (message): message is AssistantMessage => message.role === "assistant",
18521681 );
18531682 expect(assistantMessages).toHaveLength(3);
1854- expect(assistantMessages.at(-1)?.content).toEqual([
1855- {
1856- type: "text",
1857- text: "Handled reordered todos without a duplicate reminder.",
1858- },
1859- ]);
18601683 });
18611684
18621685 test("stopReason 'length' returns without looping", async () => {
src/cli.test.ts+7−11
@@ -30,18 +30,14 @@ describe("cli", () => {
3030 });
3131
3232 test("parseCliArgs rejects a missing prompt value", () => {
33- expect(() => parseCliArgs(["-p"])).toThrow(
34- "Missing value for -p/--prompt.",
35- );
36- expect(() => parseCliArgs(["--prompt"])).toThrow(
37- "Missing value for -p/--prompt.",
38- );
33+ expect(() => parseCliArgs(["-p"])).toThrow(/Missing value/);
34+ expect(() => parseCliArgs(["--prompt"])).toThrow(/Missing value/);
3935 });
4036
4137 test("parseCliArgs rejects unknown arguments", () => {
42- expect(() => parseCliArgs(["--wat"])).toThrow("Unknown argument: --wat");
38+ expect(() => parseCliArgs(["--wat"])).toThrow(/Unknown argument/);
4339 expect(() => parseCliArgs(["extra"])).toThrow(
44- "Unexpected positional argument: extra",
40+ /Unexpected positional argument/,
4541 );
4642 });
4743
@@ -101,7 +97,7 @@ describe("cli", () => {
10197 { stdinIsTTY: true, stdoutIsTTY: false },
10298 async () => "",
10399 ),
104- ).rejects.toThrow("Headless mode requires -p/--prompt or piped stdin.");
100+ ).rejects.toThrow(/-p\/--prompt or piped stdin/);
105101 });
106102
107103 test("resolveHeadlessPrompt rejects empty headless input", async () => {
@@ -111,7 +107,7 @@ describe("cli", () => {
111107 { stdinIsTTY: true, stdoutIsTTY: false },
112108 async () => "",
113109 ),
114- ).rejects.toThrow("Headless input is empty.");
110+ ).rejects.toThrow(/Headless input is empty/);
115111
116112 await expect(
117113 resolveHeadlessPrompt(
@@ -119,6 +115,6 @@ describe("cli", () => {
119115 { stdinIsTTY: false, stdoutIsTTY: true },
120116 async () => " \n",
121117 ),
122- ).rejects.toThrow("Headless input is empty.");
118+ ).rejects.toThrow(/Headless input is empty/);
123119 });
124120 });
src/headless.test.ts+1−12
@@ -155,24 +155,13 @@ describe("headless", () => {
155155 lines.push(line);
156156 },
157157 }),
158- ).rejects.toThrow("Headless mode does not support slash commands: /help");
158+ ).rejects.toThrow(/slash commands: \/help/);
159159
160160 expect(lines).toEqual([]);
161161 expect(state.session).toBeNull();
162162 expect(listPromptHistory(state.db, 1)).toEqual([]);
163163 });
164164
165- test("runHeadlessPrompt rejects /todo before creating a session", async () => {
166- const state = createTestState();
167-
168- await expect(runHeadlessPrompt(state, "/todo")).rejects.toThrow(
169- "Headless mode does not support slash commands: /todo",
170- );
171-
172- expect(state.session).toBeNull();
173- expect(listPromptHistory(state.db, 1)).toEqual([]);
174- });
175-
176165 test("runHeadlessPrompt streams only completed events for tool-use turns", async () => {
177166 faux.setResponses([
178167 fauxAssistantMessage(
src/index.test.ts+4−25
@@ -158,9 +158,10 @@ test("bin/mc.ts reports headless command errors without a stack trace", async ()
158158
159159 expect(result.exitCode).toBe(1);
160160 expect(result.stdout).toBe("");
161- expect(result.stderr).toBe(
162- "Headless mode does not support slash commands: /help\n",
161+ expect(result.stderr).toContain(
162+ "Headless mode does not support slash commands: /help",
163163 );
164+ expect(result.stderr.trim().split("\n")).toHaveLength(1);
164165 });
165166
166167 test("runHeadlessCli uses final-text mode by default in non-TTY environments", async () => {
@@ -246,7 +247,7 @@ test("loadOAuthCredentials throws a helpful error when the auth file contains in
246247 writeFileSync(path, "{not json", "utf-8");
247248
248249 expect(() => loadOAuthCredentials(path)).toThrow(
249- `Failed to read OAuth credentials ${path}:`,
250+ /Failed to read OAuth credentials .*:/,
250251 );
251252 });
252253
@@ -453,28 +454,6 @@ test("discoverCustomProviders skips providers that collide with built-in names",
453454 expect(result.warnings[0]).toContain("built-in");
454455 });
455456
456-test("discoverCustomProviders handles empty model list from endpoint", async () => {
457- const server = Bun.serve({
458- port: 0,
459- fetch() {
460- return Response.json({ data: [] });
461- },
462- });
463-
464- try {
465- const result = await discoverCustomProviders(
466- [{ name: "empty", baseUrl: `http://localhost:${server.port}` }],
467- new Set(),
468- );
469-
470- expect(result.models).toEqual([]);
471- expect(result.providers.get("empty")).toBe("no-key");
472- expect(result.warnings).toEqual([]);
473- } finally {
474- server.stop(true);
475- }
476-});
477-
478457 // ---------------------------------------------------------------------------
479458 // getAvailableModels with custom models
480459 // ---------------------------------------------------------------------------
src/input.test.ts+0−13
@@ -93,19 +93,6 @@ describe("parseInput — images", () => {
9393 });
9494 });
9595
96-// ---------------------------------------------------------------------------
97-// Plain text
98-// ---------------------------------------------------------------------------
99-
100-describe("parseInput — text", () => {
101- test("regular message is text", () => {
102- expect(parseInput("fix the tests")).toEqual({
103- type: "text",
104- text: "fix the tests",
105- });
106- });
107-});
108-
10996 // ---------------------------------------------------------------------------
11097 // Priority
11198 // ---------------------------------------------------------------------------
src/plugins.test.ts+2−13
@@ -44,11 +44,6 @@ function writePlugin(name: string, code: string): string {
4444 // ---------------------------------------------------------------------------
4545
4646 describe("loadPluginConfig", () => {
47- test("returns empty array when config file does not exist", () => {
48- const entries = loadPluginConfig(join(tmp, "nonexistent.json"));
49- expect(entries).toEqual([]);
50- });
51-
5247 test("parses plugin entries from config file", () => {
5348 const config = {
5449 plugins: [
@@ -63,12 +58,6 @@ describe("loadPluginConfig", () => {
6358 expect(entries[0]!.name).toBe("test");
6459 expect(entries[1]!.config).toEqual({ key: "value" });
6560 });
66-
67- test("returns empty array when config has no plugins key", () => {
68- writeFileSync(join(tmp, "plugins.json"), "{}");
69- const entries = loadPluginConfig(join(tmp, "plugins.json"));
70- expect(entries).toEqual([]);
71- });
7261 });
7362
7463 // ---------------------------------------------------------------------------
@@ -92,7 +81,7 @@ describe("initPlugins", () => {
9281
9382 const loaded = await initPlugins(entries, makeContext());
9483 expect(loaded).toHaveLength(1);
95- expect(loaded[0]!.result.systemPromptSuffix).toBe("Plugin context: good");
84+ expect(loaded[0]!.result.systemPromptSuffix).toContain("good");
9685 });
9786
9887 test("passes config to plugin init", async () => {
@@ -112,7 +101,7 @@ describe("initPlugins", () => {
112101 ];
113102
114103 const loaded = await initPlugins(entries, makeContext());
115- expect(loaded[0]!.result.systemPromptSuffix).toBe("key=hello");
104+ expect(loaded[0]!.result.systemPromptSuffix).toContain("hello");
116105 });
117106
118107 test("skips plugins that fail to load and reports error", async () => {
src/prompt.test.ts+0−5
@@ -50,11 +50,6 @@ describe("discoverAgentsMd", () => {
5050 expect(files[1]!.content).toBe("Src instructions");
5151 });
5252
53- test("returns empty array when no files found", () => {
54- const files = discoverAgentsMd(tmp, resolve(tmp));
55- expect(files).toEqual([]);
56- });
57-
5853 test("checks globalAgentsDir for global agent instructions", () => {
5954 const globalDir = join(tmp, "global-agents");
6055 mkdirSync(globalDir, { recursive: true });
src/session.test.ts+1−66
@@ -150,21 +150,6 @@ describe("session persistence", () => {
150150 db.close();
151151 });
152152
153- test("getSession retrieves the stored session for a known id", () => {
154- const db = openDatabase(":memory:");
155- const created = createSession(db, { cwd: "/tmp/test" });
156- const loaded = loadSessionOrThrow(db, created.id);
157- expect(loaded.id).toBe(created.id);
158- expect(loaded.cwd).toBe("/tmp/test");
159- db.close();
160- });
161-
162- test("getSession returns null for unknown id", () => {
163- const db = openDatabase(":memory:");
164- expect(getSession(db, "nonexistent")).toBeNull();
165- db.close();
166- });
167-
168153 test("listSessions returns sessions scoped to CWD, ordered by updated_at desc", () => {
169154 const db = openDatabase(":memory:");
170155 const s1 = createSession(db, { cwd: "/tmp/a" });
@@ -291,32 +276,6 @@ describe("message persistence and turn numbering", () => {
291276 db.close();
292277 });
293278
294- test("loadMessages returns all messages in insertion order", () => {
295- const db = openDatabase(":memory:");
296- const session = createSession(db, { cwd: "/tmp/test" });
297-
298- const t1 = appendMessage(db, session.id, makeUser("hello"));
299- appendMessage(db, session.id, makeAssistant("hi"), t1);
300-
301- const msgs = loadMessages(db, session.id);
302- expect(msgs).toHaveLength(2);
303- expect(msgs[0]?.role).toBe("user");
304- expect(msgs[1]?.role).toBe("assistant");
305- db.close();
306- });
307-
308- test("loadMessages round-trips persisted UI messages", () => {
309- const db = openDatabase(":memory:");
310- const session = createSession(db, { cwd: "/tmp/test" });
311- const uiMessage = makeUiMessage("Help output");
312-
313- appendMessage(db, session.id, uiMessage);
314-
315- const msgs = loadMessages(db, session.id);
316- expect(msgs).toEqual([uiMessage]);
317- db.close();
318- });
319-
320279 test("loadMessages round-trips markdown-formatted UI info messages", () => {
321280 const db = openDatabase(":memory:");
322281 const session = createSession(db, { cwd: "/tmp/test" });
@@ -474,15 +433,7 @@ describe("undo", () => {
474433
475434 const msgs = loadMessages(db, session.id);
476435 expect(msgs).toHaveLength(2);
477- expect((msgs[0] as UserMessage).content).toBe("first");
478- expect(
479- (
480- (msgs[1] as AssistantMessage).content[0] as {
481- type: "text";
482- text: string;
483- }
484- ).text,
485- ).toBe("reply1");
436+ expect(msgs.map((msg) => msg.role)).toEqual(["user", "assistant"]);
486437 db.close();
487438 });
488439
@@ -527,15 +478,6 @@ describe("undo", () => {
527478 "ui",
528479 "ui",
529480 ]);
530- expect((msgs[0] as ReturnType<typeof makeUiMessage>).content).toBe(
531- "Help output",
532- );
533- expect((msgs[3] as ReturnType<typeof makeUiMessage>).content).toBe(
534- "OAuth progress",
535- );
536- expect((msgs[4] as ReturnType<typeof makeUiMessage>).content).toBe(
537- "Still visible",
538- );
539481 db.close();
540482 });
541483
@@ -753,13 +695,6 @@ describe("cumulative stats", () => {
753695 expect(stats.totalCost).toBeCloseTo(0.009);
754696 });
755697
756- test("computeStats returns zeros for empty history", () => {
757- const stats = computeStats([]);
758- expect(stats.totalInput).toBe(0);
759- expect(stats.totalOutput).toBe(0);
760- expect(stats.totalCost).toBe(0);
761- });
762-
763698 test("computeStats ignores non-assistant messages", () => {
764699 const messages = [
765700 makeUser("hello"),
src/settings.test.ts+2−11
@@ -31,13 +31,6 @@ afterEach(() => {
3131 });
3232
3333 describe("settings", () => {
34- test("loadSettings returns empty object when the file does not exist", () => {
35- const dir = createTempDir();
36- const path = join(dir, "settings.json");
37-
38- expect(loadSettings(path)).toEqual({});
39- });
40-
4134 test("loadSettings parses valid settings", () => {
4235 const dir = createTempDir();
4336 const path = join(dir, "settings.json");
@@ -57,9 +50,7 @@ describe("settings", () => {
5750 const path = join(dir, "settings.json");
5851 writeFileSync(path, "{not json", "utf-8");
5952
60- expect(() => loadSettings(path)).toThrow(
61- `Failed to read settings ${path}:`,
62- );
53+ expect(() => loadSettings(path)).toThrow(/Failed to read settings .*:/);
6354 });
6455
6556 test("updateSettings preserves an invalid settings file instead of overwriting it", () => {
@@ -69,7 +60,7 @@ describe("settings", () => {
6960 writeFileSync(path, invalidJson, "utf-8");
7061
7162 expect(() => updateSettings(path, { verbose: true })).toThrow(
72- `Failed to read settings ${path}:`,
63+ /Failed to read settings .*:/,
7364 );
7465 expect(readFileSync(path, "utf-8")).toBe(invalidJson);
7566 });
src/skills.test.ts+0−22
@@ -38,28 +38,6 @@ function writeSkill(basePath: string, name: string, content: string): string {
3838 // ---------------------------------------------------------------------------
3939
4040 describe("discoverSkills", () => {
41- test("discovers skills from a single scan path", () => {
42- writeSkill(
43- tmp,
44- "code-review",
45- [
46- "---",
47- "name: code-review",
48- 'description: "Review code for bugs."',
49- "---",
50- "",
51- "# Code Review",
52- "Do a review.",
53- ].join("\n"),
54- );
55-
56- const skills = discoverSkills([tmp]);
57- expect(skills).toHaveLength(1);
58- expect(skills[0]!.name).toBe("code-review");
59- expect(skills[0]!.description).toBe("Review code for bugs.");
60- expect(skills[0]!.path).toBe(join(tmp, "code-review", "SKILL.md"));
61- });
62-
6341 test("project-level skill overrides user-level on name collision", () => {
6442 // Earlier paths in the array have higher priority (project-level first)
6543 const project = join(tmp, "project");
src/tools.test.ts+4−8
@@ -110,9 +110,8 @@ describe("edit", () => {
110110 );
111111
112112 expect(result.isError).toBe(true);
113- expect(resultText(result)).toContain("Old text not found in a.txt");
114- expect(resultText(result)).toContain("Closest matches:");
115- expect(resultText(result)).toContain("lines 1-3");
113+ expect(resultText(result)).toContain("Old text not found");
114+ expect(resultText(result)).toContain("line");
116115 expect(resultText(result)).toContain('return "hello";');
117116 // File unchanged
118117 expect(readFile("a.txt")).toBe(
@@ -135,10 +134,7 @@ describe("edit", () => {
135134 );
136135
137136 expect(result.isError).toBe(true);
138- expect(resultText(result)).toContain(
139- "Old text matches multiple locations (2) in a.txt",
140- );
141- expect(resultText(result)).toContain("Matches:");
137+ expect(resultText(result)).toContain("Old text matches multiple locations");
142138 expect(resultText(result)).toContain("line 1");
143139 expect(resultText(result)).toContain("line 3");
144140 expect(resultText(result)).toContain("const value = 1;");
@@ -415,7 +411,7 @@ describe("todo tools", () => {
415411 );
416412
417413 expect(result.isError).toBe(true);
418- expect(resultText(result)).toBe("Todo content cannot be empty");
414+ expect(resultText(result)).toContain("cannot be empty");
419415 });
420416 });
421417
src/ui.test.ts+4−3
@@ -558,9 +558,10 @@ describe("ui rendering", () => {
558558 throw new Error("Expected a text user message");
559559 }
560560
561- expect(userMessage.content).toBe(
562- "# Review Checklist\n- Find bugs\n- Note missing tests\n\ncheck the auth module",
563- );
561+ expect(userMessage.content).toContain("# Review Checklist");
562+ expect(userMessage.content).toContain("- Find bugs");
563+ expect(userMessage.content).toContain("- Note missing tests");
564+ expect(userMessage.content).toEndWith("check the auth module");
564565 expect(userMessage.content).not.toContain("name: code-review");
565566
566567 const history = state.db
src/ui/commands.test.ts+2−5
@@ -153,8 +153,6 @@ describe("ui/commands", () => {
153153 expect(controller.handleCommand("session", state)).toBe(true);
154154
155155 const overlay = expectOverlay(runtimeState.overlay);
156- expect(overlay.title).toBe("Resume a session");
157-
158156 const selectNode = renderSelect(overlay);
159157 selectNode.props.onKeyPress?.("enter");
160158
@@ -284,7 +282,7 @@ describe("ui/commands", () => {
284282 }
285283 });
286284
287- test("/help appends markdown help without creating a session", () => {
285+ test("/help appends a markdown info message without creating a session", () => {
288286 const state = createTestState();
289287 const appended: Array<{
290288 text: string;
@@ -312,8 +310,7 @@ describe("ui/commands", () => {
312310 try {
313311 expect(controller.handleCommand("help", state)).toBe(true);
314312 expect(appended).toHaveLength(1);
315- expect(appended[0]?.text).toContain("# Help");
316- expect(appended[0]?.text).toContain("## Commands");
313+ expect(appended[0]?.text.length).toBeGreaterThan(0);
317314 expect(appended[0]?.format).toBe("markdown");
318315 expect(appended[0]?.sessionId).toBeNull();
319316 expect(state.session).toBeNull();
src/ui/input.test.ts+1−43
@@ -2,13 +2,7 @@ import { afterEach, describe, expect, test } from "bun:test";
22 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
33 import { tmpdir } from "node:os";
44 import { join } from "node:path";
5-import { DEFAULT_THEME } from "../theme.ts";
6-import {
7- autocompleteInputPath,
8- findInputPathMatches,
9- type InputController,
10- renderInputArea,
11-} from "./input.ts";
5+import { autocompleteInputPath, findInputPathMatches } from "./input.ts";
126
137 const tempDirs: string[] = [];
148
@@ -24,43 +18,7 @@ afterEach(() => {
2418 }
2519 });
2620
27-function expectTextInput(node: ReturnType<typeof renderInputArea>) {
28- if (node.type !== "textinput") {
29- throw new Error("Expected a TextInput node");
30- }
31- return node;
32-}
33-
3421 describe("ui/input", () => {
35- test("renderInputArea shows the current draft with the configured placeholder and size limits", () => {
36- const controller: InputController = {
37- onChange: () => {},
38- onFocus: () => {},
39- onBlur: () => {},
40- onKeyPress: () => undefined,
41- };
42-
43- const input = expectTextInput(
44- renderInputArea(DEFAULT_THEME, controller, "draft", true),
45- );
46- const placeholder = input.props.placeholder;
47-
48- expect(input.props.value).toBe("draft");
49- expect(input.props.focused).toBe(true);
50- expect(input.props.minHeight).toBe(2);
51- expect(input.props.maxHeight).toBe(10);
52- expect(input.props.padding).toEqual({ x: 1 });
53- expect(placeholder?.type).toBe("text");
54- if (!placeholder || placeholder.type !== "text") {
55- throw new Error("Expected a text placeholder");
56- }
57- expect(placeholder.content).toBe(
58- "`Ctrl+R` for input history, `/` + `Tab` for interactive menu, or type a message…",
59- );
60- expect(placeholder.props.fgColor).toBe(DEFAULT_THEME.mutedText);
61- expect(placeholder.props.italic).toBe(true);
62- });
63-
6422 test("autocompleteInputPath completes the last file path token when exactly one match is available", () => {
6523 const cwd = createTempDir();
6624 mkdirSync(join(cwd, "src"), { recursive: true });