pi-oxidized 0.1.1

package/.references/pi/packages/coding-agent/test/suite/regressions/pre-prompt-compaction-no-continue.test.ts

@@ -0,0 +1,75 @@
+import { type AssistantMessage, fauxAssistantMessage } from "@earendil-works/pi-ai";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createHarness, getUserTexts, type Harness } from "../harness.ts";
+
+function createUsage(totalTokens: number) {
+	return {
+		input: totalTokens,
+		output: 0,
+		cacheRead: 0,
+		cacheWrite: 0,
+		totalTokens,
+		cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+	};
+}
+
+describe("pre-prompt compaction regression", () => {
+	const harnesses: Harness[] = [];
+
+	afterEach(() => {
+		vi.restoreAllMocks();
+		while (harnesses.length > 0) {
+			harnesses.pop()?.cleanup();
+		}
+	});
+
+	it("compacts length-stop overflow before a new prompt without continuing from an assistant message", async () => {
+		const harness = await createHarness({
+			models: [{ id: "faux-1", contextWindow: 100, maxTokens: 100 }],
+			settings: { compaction: { enabled: true, keepRecentTokens: 1, reserveTokens: 0 } },
+			extensionFactories: [
+				(pi) => {
+					pi.on("session_before_compact", async (event) => ({
+						compaction: {
+							summary: "pre-prompt summary",
+							firstKeptEntryId: event.preparation.firstKeptEntryId,
+							tokensBefore: event.preparation.tokensBefore,
+							details: {},
+						},
+					}));
+				},
+			],
+		});
+		harnesses.push(harness);
+
+		const now = Date.now();
+		const model = harness.getModel();
+		harness.sessionManager.appendMessage({
+			role: "user",
+			content: [{ type: "text", text: "previous prompt" }],
+			timestamp: now - 1000,
+		});
+		const lengthStopAssistant: AssistantMessage = {
+			...fauxAssistantMessage("length-stop assistant response", { stopReason: "length", timestamp: now - 500 }),
+			api: model.api,
+			provider: model.provider,
+			model: model.id,
+			usage: createUsage(100),
+		};
+		harness.sessionManager.appendMessage(lengthStopAssistant);
+		harness.session.agent.state.messages = harness.sessionManager.buildSessionContext().messages;
+		harness.setResponses([fauxAssistantMessage("answered next prompt")]);
+		const continueSpy = vi.spyOn(harness.session.agent, "continue");
+
+		await expect(harness.session.prompt("next prompt")).resolves.toBeUndefined();
+
+		expect(continueSpy).not.toHaveBeenCalled();
+		expect(harness.eventsOfType("compaction_end").at(-1)).toMatchObject({
+			reason: "overflow",
+			aborted: false,
+			willRetry: true,
+		});
+		expect(getUserTexts(harness)).toContain("next prompt");
+		expect(harness.faux.state.callCount).toBe(1);
+	});
+});

package/.references/pi/packages/coding-agent/test/syntax-highlight.test.ts

@@ -0,0 +1,76 @@
+import { resetCapabilitiesCache, setCapabilities } from "@earendil-works/pi-tui";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { highlightCode, initTheme } from "../src/modes/interactive/theme/theme.ts";
+import { highlight, renderHighlightedHtml, supportsLanguage } from "../src/utils/syntax-highlight.ts";
+
+describe("syntax highlight renderer", () => {
+	it("renders highlighted spans with the provided theme", () => {
+		const rendered = renderHighlightedHtml('<span class="hljs-keyword">const</span> value', {
+			keyword: (text) => `[keyword:${text}]`,
+		});
+		expect(rendered).toBe("[keyword:const] value");
+	});
+
+	it("decodes HTML entities emitted by highlight.js", () => {
+		const rendered = renderHighlightedHtml("&lt;tag attr=&quot;value&quot;&gt;&amp;#x41;&#65;&lt;/tag&gt;");
+		expect(rendered).toBe('<tag attr="value">&#x41;A</tag>');
+	});
+
+	it("inherits parent formatting for unmapped nested scopes", () => {
+		const interpolation = "$" + "{x}";
+		const rendered = renderHighlightedHtml(
+			`<span class="hljs-string">a<span class="hljs-subst">${interpolation}</span>b</span>`,
+			{
+				string: (text) => `[string:${text}]`,
+			},
+		);
+		expect(rendered).toBe(`[string:a][string:${interpolation}][string:b]`);
+	});
+
+	it("keeps parent formatting across unscoped nested spans", () => {
+		const rendered = renderHighlightedHtml('<span class="hljs-string">a<span class="language-xml">b</span>c</span>', {
+			string: (text) => `[string:${text}]`,
+		});
+		expect(rendered).toBe("[string:a][string:b][string:c]");
+	});
+
+	it("highlights code through highlight.js", () => {
+		expect(supportsLanguage("typescript")).toBe(true);
+		const rendered = highlight("const value = 1", {
+			language: "typescript",
+			ignoreIllegals: true,
+			theme: {
+				keyword: (text) => `[keyword:${text}]`,
+				number: (text) => `[number:${text}]`,
+			},
+		});
+		expect(rendered).toContain("[keyword:const]");
+		expect(rendered).toContain("[number:1]");
+	});
+});
+
+describe("theme syntax highlighting", () => {
+	beforeEach(() => {
+		setCapabilities({ images: null, trueColor: true, hyperlinks: false });
+		initTheme("dark");
+	});
+
+	afterEach(() => {
+		resetCapabilitiesCache();
+	});
+
+	it("colors diff additions and deletions in fenced diff blocks", () => {
+		const lines = highlightCode("-old\n+new\n", "diff");
+
+		expect(lines[0]).toBe("\x1b[38;2;204;102;102m-old\x1b[39m");
+		expect(lines[1]).toBe("\x1b[38;2;181;189;104m+new\x1b[39m");
+	});
+
+	it("keeps cli-highlight default styled scopes mapped to theme styles", () => {
+		expect(highlightCode("const re = /foo+/gi;", "javascript")[0]).toContain(
+			"\x1b[38;2;206;145;120m/foo+/gi\x1b[39m",
+		);
+		expect(highlightCode("@decorator", "python")[0]).toBe("\x1b[38;2;128;128;128m@decorator\x1b[39m");
+		expect(highlightCode("<div></div>", "html")[0]).toContain("\x1b[38;2;86;156;214mdiv\x1b[39m");
+	});
+});

package/.references/pi/packages/coding-agent/test/system-prompt.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "vitest";
+import { buildSystemPrompt } from "../src/core/system-prompt.ts";
+
+describe("buildSystemPrompt", () => {
+	describe("empty tools", () => {
+		test("shows (none) for empty tools list", () => {
+			const prompt = buildSystemPrompt({
+				selectedTools: [],
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).toContain("Available tools:\n(none)");
+		});
+
+		test("shows file paths guideline even with no tools", () => {
+			const prompt = buildSystemPrompt({
+				selectedTools: [],
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).toContain("Show file paths clearly");
+		});
+	});
+
+	describe("default tools", () => {
+		test("includes all default tools when snippets are provided", () => {
+			const prompt = buildSystemPrompt({
+				toolSnippets: {
+					read: "Read file contents",
+					bash: "Execute bash commands",
+					edit: "Make surgical edits",
+					write: "Create or overwrite files",
+				},
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).toContain("- read:");
+			expect(prompt).toContain("- bash:");
+			expect(prompt).toContain("- edit:");
+			expect(prompt).toContain("- write:");
+		});
+
+		test("instructs models to resolve pi docs and examples under absolute base paths", () => {
+			const prompt = buildSystemPrompt({
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).toContain(
+				"- When reading pi docs or examples, resolve docs/... under Additional docs and examples/... under Examples, not the current working directory",
+			);
+		});
+	});
+
+	describe("custom tool snippets", () => {
+		test("includes custom tools in available tools section when promptSnippet is provided", () => {
+			const prompt = buildSystemPrompt({
+				selectedTools: ["read", "dynamic_tool"],
+				toolSnippets: {
+					dynamic_tool: "Run dynamic test behavior",
+				},
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).toContain("- dynamic_tool: Run dynamic test behavior");
+		});
+
+		test("omits custom tools from available tools section when promptSnippet is not provided", () => {
+			const prompt = buildSystemPrompt({
+				selectedTools: ["read", "dynamic_tool"],
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).not.toContain("dynamic_tool");
+		});
+	});
+
+	describe("prompt guidelines", () => {
+		test("appends promptGuidelines to default guidelines", () => {
+			const prompt = buildSystemPrompt({
+				selectedTools: ["read", "dynamic_tool"],
+				promptGuidelines: ["Use dynamic_tool for project summaries."],
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt).toContain("- Use dynamic_tool for project summaries.");
+		});
+
+		test("deduplicates and trims promptGuidelines", () => {
+			const prompt = buildSystemPrompt({
+				selectedTools: ["read", "dynamic_tool"],
+				promptGuidelines: ["Use dynamic_tool for summaries.", "  Use dynamic_tool for summaries.  ", "   "],
+				contextFiles: [],
+				skills: [],
+				cwd: process.cwd(),
+			});
+
+			expect(prompt.match(/- Use dynamic_tool for summaries\./g)).toHaveLength(1);
+		});
+	});
+});

package/.references/pi/packages/coding-agent/test/test-harness.test.ts

@@ -0,0 +1,321 @@
+/**
+ * Tests for the test harness itself.
+ * Validates that the faux provider and session factory work correctly.
+ */
+
+import type { AgentTool } from "@earendil-works/pi-agent-core";
+import type { AssistantMessage } from "@earendil-works/pi-ai";
+import { Type } from "typebox";
+import { afterEach, describe, expect, it } from "vitest";
+import { createHarness, createHarnessWithExtensions, type Harness } from "./test-harness.ts";
+
+describe("test harness", () => {
+	let harness: Harness;
+
+	afterEach(() => {
+		harness?.cleanup();
+	});
+
+	it("simple text response", async () => {
+		harness = await createHarness({ responses: ["hello world"] });
+
+		await harness.session.prompt("hi");
+
+		expect(harness.faux.callCount).toBe(1);
+
+		const assistantMessages = harness.session.messages.filter((m) => m.role === "assistant");
+		expect(assistantMessages).toHaveLength(1);
+
+		const msg = assistantMessages[0] as AssistantMessage;
+		expect(msg.content).toEqual([{ type: "text", text: "hello world" }]);
+		expect(msg.stopReason).toBe("stop");
+	});
+
+	it("response sequence", async () => {
+		harness = await createHarness({ responses: ["first", "second", "third"] });
+
+		await harness.session.prompt("a");
+		await harness.session.prompt("b");
+		await harness.session.prompt("c");
+
+		expect(harness.faux.callCount).toBe(3);
+
+		const assistantTexts = harness.session.messages
+			.filter((m): m is AssistantMessage => m.role === "assistant")
+			.map((m) => m.content.find((c) => c.type === "text")?.text);
+
+		expect(assistantTexts).toEqual(["first", "second", "third"]);
+	});
+
+	it("tool call response triggers tool execution", async () => {
+		let toolExecuted = false;
+		const echoTool: AgentTool = {
+			name: "echo",
+			label: "Echo",
+			description: "Echo back",
+			parameters: Type.Object({ text: Type.String() }),
+			execute: async () => {
+				toolExecuted = true;
+				return { content: [{ type: "text", text: "echoed" }], details: {} };
+			},
+		};
+
+		harness = await createHarness({
+			responses: [{ toolCalls: [{ name: "echo", args: { text: "hi" } }] }, "done after tool"],
+			tools: [echoTool],
+			baseToolsOverride: { echo: echoTool },
+		});
+
+		await harness.session.prompt("use the tool");
+
+		expect(toolExecuted).toBe(true);
+		expect(harness.faux.callCount).toBe(2);
+
+		const toolResults = harness.session.messages.filter((m) => m.role === "toolResult");
+		expect(toolResults).toHaveLength(1);
+	});
+
+	it("error response", async () => {
+		harness = await createHarness({
+			responses: [{ error: "something broke" }],
+		});
+
+		await harness.session.prompt("hi");
+
+		const assistantMessages = harness.session.messages.filter((m): m is AssistantMessage => m.role === "assistant");
+		expect(assistantMessages).toHaveLength(1);
+		expect(assistantMessages[0].stopReason).toBe("error");
+		expect(assistantMessages[0].errorMessage).toBe("something broke");
+	});
+
+	it("retry on transient error", async () => {
+		harness = await createHarness({
+			responses: [{ error: "overloaded_error" }, "recovered"],
+			settings: { retry: { enabled: true, maxRetries: 3, baseDelayMs: 1 } },
+		});
+
+		await harness.session.prompt("hi");
+
+		expect(harness.faux.callCount).toBe(2);
+
+		const retryStarts = harness.eventsOfType("auto_retry_start");
+		expect(retryStarts).toHaveLength(1);
+
+		const retryEnds = harness.eventsOfType("auto_retry_end");
+		expect(retryEnds).toHaveLength(1);
+		expect(retryEnds[0].success).toBe(true);
+	});
+
+	it("custom usage numbers", async () => {
+		harness = await createHarness({
+			responses: [{ text: "big response", usage: { input: 100000, output: 5000 } }],
+		});
+
+		await harness.session.prompt("hi");
+
+		const msg = harness.session.messages.find((m): m is AssistantMessage => m.role === "assistant")!;
+		expect(msg.usage.input).toBe(100000);
+		expect(msg.usage.output).toBe(5000);
+	});
+
+	it("event capture", async () => {
+		harness = await createHarness({ responses: ["hello"] });
+
+		await harness.session.prompt("hi");
+
+		const agentStarts = harness.eventsOfType("agent_start");
+		expect(agentStarts).toHaveLength(1);
+
+		const agentEnds = harness.eventsOfType("agent_end");
+		expect(agentEnds).toHaveLength(1);
+
+		const messageEnds = harness.eventsOfType("message_end");
+		expect(messageEnds.length).toBeGreaterThanOrEqual(2); // user + assistant
+	});
+
+	it("context capture", async () => {
+		harness = await createHarness({ responses: ["reply"] });
+
+		await harness.session.prompt("my question");
+
+		expect(harness.faux.contexts).toHaveLength(1);
+		const ctx = harness.faux.contexts[0];
+		const userMsg = ctx.messages.find((m) => m.role === "user");
+		expect(userMsg).toBeDefined();
+	});
+
+	it("wraps around when more calls than responses", async () => {
+		harness = await createHarness({ responses: ["a", "b"] });
+
+		await harness.session.prompt("1");
+		await harness.session.prompt("2");
+		await harness.session.prompt("3");
+
+		expect(harness.faux.callCount).toBe(3);
+
+		const texts = harness.session.messages
+			.filter((m): m is AssistantMessage => m.role === "assistant")
+			.map((m) => m.content.find((c) => c.type === "text")?.text);
+
+		expect(texts).toEqual(["a", "b", "a"]);
+	});
+
+	it("streams text deltas", async () => {
+		harness = await createHarness({ responses: ["hello world"] });
+
+		await harness.session.prompt("hi");
+
+		const updates = harness.eventsOfType("message_update");
+		const textDeltas = updates.filter((e) => e.assistantMessageEvent.type === "text_delta");
+		expect(textDeltas.length).toBeGreaterThan(0);
+
+		// Deltas should reconstruct the full text
+		const reconstructed = textDeltas.map((e) => (e.assistantMessageEvent as { delta: string }).delta).join("");
+		expect(reconstructed).toBe("hello world");
+	});
+
+	it("streams thinking deltas", async () => {
+		harness = await createHarness({
+			responses: [{ thinking: "let me think about this", text: "answer" }],
+		});
+
+		await harness.session.prompt("hi");
+
+		const updates = harness.eventsOfType("message_update");
+		const thinkingStarts = updates.filter((e) => e.assistantMessageEvent.type === "thinking_start");
+		const thinkingDeltas = updates.filter((e) => e.assistantMessageEvent.type === "thinking_delta");
+		const thinkingEnds = updates.filter((e) => e.assistantMessageEvent.type === "thinking_end");
+
+		expect(thinkingStarts).toHaveLength(1);
+		expect(thinkingDeltas.length).toBeGreaterThan(0);
+		expect(thinkingEnds).toHaveLength(1);
+
+		const reconstructed = thinkingDeltas.map((e) => (e.assistantMessageEvent as { delta: string }).delta).join("");
+		expect(reconstructed).toBe("let me think about this");
+	});
+
+	it("streams tool call deltas", async () => {
+		const echoTool: AgentTool = {
+			name: "echo",
+			label: "Echo",
+			description: "Echo back",
+			parameters: Type.Object({ text: Type.String() }),
+			execute: async () => ({ content: [{ type: "text", text: "echoed" }], details: {} }),
+		};
+
+		harness = await createHarness({
+			responses: [{ toolCalls: [{ name: "echo", args: { text: "hi" } }] }, "done"],
+			tools: [echoTool],
+			baseToolsOverride: { echo: echoTool },
+		});
+
+		await harness.session.prompt("use tool");
+
+		const updates = harness.eventsOfType("message_update");
+		const toolcallStarts = updates.filter((e) => e.assistantMessageEvent.type === "toolcall_start");
+		const toolcallDeltas = updates.filter((e) => e.assistantMessageEvent.type === "toolcall_delta");
+		const toolcallEnds = updates.filter((e) => e.assistantMessageEvent.type === "toolcall_end");
+
+		expect(toolcallStarts).toHaveLength(1);
+		expect(toolcallDeltas.length).toBeGreaterThan(0);
+		expect(toolcallEnds).toHaveLength(1);
+	});
+
+	it("streams thinking then text then tool call in order", async () => {
+		const echoTool: AgentTool = {
+			name: "echo",
+			label: "Echo",
+			description: "Echo back",
+			parameters: Type.Object({ text: Type.String() }),
+			execute: async () => ({ content: [{ type: "text", text: "echoed" }], details: {} }),
+		};
+
+		harness = await createHarness({
+			responses: [
+				{
+					thinking: "hmm",
+					text: "I will call a tool",
+					toolCalls: [{ name: "echo", args: { text: "x" } }],
+				},
+				"final",
+			],
+			tools: [echoTool],
+			baseToolsOverride: { echo: echoTool },
+		});
+
+		await harness.session.prompt("do it");
+
+		const updates = harness.eventsOfType("message_update");
+		const streamTypes = updates.map((e) => e.assistantMessageEvent.type);
+
+		// Thinking events should come before text events, text before toolcall
+		const firstThinking = streamTypes.indexOf("thinking_start");
+		const firstText = streamTypes.indexOf("text_start");
+		const firstToolcall = streamTypes.indexOf("toolcall_start");
+
+		expect(firstThinking).toBeLessThan(firstText);
+		expect(firstText).toBeLessThan(firstToolcall);
+	});
+
+	it("loads inline extension factories and disambiguates duplicate commands", async () => {
+		const calls: string[] = [];
+
+		harness = await createHarnessWithExtensions({
+			extensionFactories: [
+				{
+					path: "<alpha>",
+					factory: (pi) => {
+						pi.registerCommand("shared-cmd", {
+							description: "Alpha command",
+							handler: async (args) => {
+								calls.push(`alpha:${args}`);
+							},
+						});
+					},
+				},
+				{
+					path: "<beta>",
+					factory: (pi) => {
+						pi.registerCommand("shared-cmd", {
+							description: "Beta command",
+							handler: async (args) => {
+								calls.push(`beta:${args}`);
+							},
+						});
+					},
+				},
+			],
+		});
+
+		const runner = harness.session.extensionRunner;
+		expect(runner).toBeDefined();
+
+		const commands = runner!.getRegisteredCommands();
+		expect(
+			commands.map((command) => ({
+				name: command.name,
+				invocationName: command.invocationName,
+				description: command.description,
+				path: command.sourceInfo.path,
+			})),
+		).toEqual([
+			{ name: "shared-cmd", invocationName: "shared-cmd:1", description: "Alpha command", path: "<alpha>" },
+			{ name: "shared-cmd", invocationName: "shared-cmd:2", description: "Beta command", path: "<beta>" },
+		]);
+
+		await runner!.getCommand("shared-cmd:1")?.handler("first", runner!.createCommandContext());
+		await runner!.getCommand("shared-cmd:2")?.handler("second", runner!.createCommandContext());
+
+		expect(calls).toEqual(["alpha:first", "beta:second"]);
+	});
+
+	it("session persistence works", async () => {
+		harness = await createHarness({ responses: ["persisted"] });
+
+		await harness.session.prompt("hi");
+
+		const entries = harness.sessionManager.getEntries();
+		const messageEntries = entries.filter((e) => e.type === "message");
+		expect(messageEntries.length).toBeGreaterThanOrEqual(2); // user + assistant
+	});
+});