pi-usereq 0.6.0 → 0.10.0

package/pi.dev-src/pi-mono/coding-agent/test/path-utils.test.ts

@@ -0,0 +1,162 @@
+import { mkdtempSync, readdirSync, rmdirSync, unlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { expandPath, resolveReadPath, resolveToCwd } from "../src/core/tools/path-utils.js";
+
+describe("path-utils", () => {
+	describe("expandPath", () => {
+		it("should expand ~ to home directory", () => {
+			const result = expandPath("~");
+			expect(result).not.toContain("~");
+		});
+
+		it("should expand ~/path to home directory", () => {
+			const result = expandPath("~/Documents/file.txt");
+			expect(result).not.toContain("~/");
+		});
+
+		it("should normalize Unicode spaces", () => {
+			// Non-breaking space (U+00A0) should become regular space
+			const withNBSP = "file\u00A0name.txt";
+			const result = expandPath(withNBSP);
+			expect(result).toBe("file name.txt");
+		});
+	});
+
+	describe("resolveToCwd", () => {
+		it("should resolve absolute paths as-is", () => {
+			const result = resolveToCwd("/absolute/path/file.txt", "/some/cwd");
+			expect(result).toBe("/absolute/path/file.txt");
+		});
+
+		it("should resolve relative paths against cwd", () => {
+			const result = resolveToCwd("relative/file.txt", "/some/cwd");
+			expect(result).toBe(resolve("/some/cwd", "relative/file.txt"));
+		});
+	});
+
+	describe("resolveReadPath", () => {
+		let tempDir: string;
+
+		beforeEach(() => {
+			tempDir = mkdtempSync(join(tmpdir(), "path-utils-test-"));
+		});
+
+		afterEach(() => {
+			// Clean up temp files and directory
+			try {
+				const files = readdirSync(tempDir);
+				for (const file of files) {
+					unlinkSync(join(tempDir, file));
+				}
+				rmdirSync(tempDir);
+			} catch {
+				// Ignore cleanup errors
+			}
+		});
+
+		it("should resolve existing file path", () => {
+			const fileName = "test-file.txt";
+			writeFileSync(join(tempDir, fileName), "content");
+
+			const result = resolveReadPath(fileName, tempDir);
+			expect(result).toBe(join(tempDir, fileName));
+		});
+
+		it("should handle NFC vs NFD Unicode normalization (macOS filenames with accents)", () => {
+			// macOS stores filenames in NFD (decomposed) form:
+			//   é = e + combining acute accent (U+0301)
+			// Users typically type in NFC (composed) form:
+			//   é = single character (U+00E9)
+			//
+			// Note: macOS APFS normalizes Unicode automatically, so both paths work.
+			// This test verifies the NFD variant fallback works on systems that don't.
+
+			// NFD: e (U+0065) + combining acute accent (U+0301)
+			const nfdFileName = "file\u0065\u0301.txt";
+			// NFC: é as single character (U+00E9)
+			const nfcFileName = "file\u00e9.txt";
+
+			// Verify they have different byte sequences
+			expect(nfdFileName).not.toBe(nfcFileName);
+			expect(Buffer.from(nfdFileName)).not.toEqual(Buffer.from(nfcFileName));
+
+			// Create file with NFD name
+			writeFileSync(join(tempDir, nfdFileName), "content");
+
+			// User provides NFC path - should find the file (via filesystem normalization or our fallback)
+			const result = resolveReadPath(nfcFileName, tempDir);
+			// Result should contain the accented character (either NFC or NFD form)
+			expect(result).toContain(tempDir);
+			expect(result).toMatch(/file.+\.txt$/);
+		});
+
+		it("should handle curly quotes vs straight quotes (macOS filenames)", () => {
+			// macOS uses curly apostrophe (U+2019) in screenshot filenames:
+			//   Capture d'écran (U+2019)
+			// Users typically type straight apostrophe (U+0027):
+			//   Capture d'ecran (U+0027)
+
+			const curlyQuoteName = "Capture d\u2019cran.txt"; // U+2019 right single quotation mark
+			const straightQuoteName = "Capture d'cran.txt"; // U+0027 apostrophe
+
+			// Verify they are different
+			expect(curlyQuoteName).not.toBe(straightQuoteName);
+
+			// Create file with curly quote name (simulating macOS behavior)
+			writeFileSync(join(tempDir, curlyQuoteName), "content");
+
+			// User provides straight quote path - should find the curly quote file
+			const result = resolveReadPath(straightQuoteName, tempDir);
+			expect(result).toBe(join(tempDir, curlyQuoteName));
+		});
+
+		it("should handle combined NFC + curly quote (French macOS screenshots)", () => {
+			// Full macOS screenshot filename: "Capture d'écran" with NFD é and curly quote
+			// Note: macOS APFS normalizes NFD to NFC, so the actual file on disk uses NFC
+			const nfcCurlyName = "Capture d\u2019\u00e9cran.txt"; // NFC + curly quote (how APFS stores it)
+			const nfcStraightName = "Capture d'\u00e9cran.txt"; // NFC + straight quote (user input)
+
+			// Verify they are different
+			expect(nfcCurlyName).not.toBe(nfcStraightName);
+
+			// Create file with macOS-style name (curly quote)
+			writeFileSync(join(tempDir, nfcCurlyName), "content");
+
+			// User provides straight quote path - should find the curly quote file
+			const result = resolveReadPath(nfcStraightName, tempDir);
+			expect(result).toBe(join(tempDir, nfcCurlyName));
+		});
+
+		it("should handle macOS screenshot AM/PM variant with narrow no-break space", () => {
+			// macOS uses narrow no-break space (U+202F) before AM/PM in screenshot names
+			const macosName = "Screenshot 2024-01-01 at 10.00.00\u202FAM.png"; // U+202F
+			const userName = "Screenshot 2024-01-01 at 10.00.00 AM.png"; // regular space
+
+			// Create file with macOS-style name
+			writeFileSync(join(tempDir, macosName), "content");
+
+			// User provides regular space path
+			const result = resolveReadPath(userName, tempDir);
+
+			// This works because tryMacOSScreenshotPath() handles this case
+			expect(result).toBe(join(tempDir, macosName));
+		});
+
+		it("should handle macOS screenshot lowercase am/pm variant (en_AU locale)", () => {
+			// Some locales like en_AU use lowercase am/pm in screenshot names
+			const macosName = "Screenshot 2024-01-01 at 10.00.00\u202Fam.png"; // U+202F + lowercase
+			const userName = "Screenshot 2024-01-01 at 10.00.00 am.png"; // regular space + lowercase
+
+			// Create file with macOS-style name
+			writeFileSync(join(tempDir, macosName), "content");
+
+			// User provides regular space path
+			const result = resolveReadPath(userName, tempDir);
+
+			// This works because tryMacOSScreenshotPath() uses case-insensitive matching
+			expect(result).toBe(join(tempDir, macosName));
+		});
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/plan-mode-utils.test.ts

@@ -0,0 +1,261 @@
+import { describe, expect, it } from "vitest";
+import {
+	cleanStepText,
+	extractDoneSteps,
+	extractTodoItems,
+	isSafeCommand,
+	markCompletedSteps,
+	type TodoItem,
+} from "../examples/extensions/plan-mode/utils.js";
+
+describe("isSafeCommand", () => {
+	describe("safe commands", () => {
+		it("allows basic read commands", () => {
+			expect(isSafeCommand("ls -la")).toBe(true);
+			expect(isSafeCommand("cat file.txt")).toBe(true);
+			expect(isSafeCommand("head -n 10 file.txt")).toBe(true);
+			expect(isSafeCommand("tail -f log.txt")).toBe(true);
+			expect(isSafeCommand("grep pattern file")).toBe(true);
+			expect(isSafeCommand("find . -name '*.ts'")).toBe(true);
+		});
+
+		it("allows git read commands", () => {
+			expect(isSafeCommand("git status")).toBe(true);
+			expect(isSafeCommand("git log --oneline")).toBe(true);
+			expect(isSafeCommand("git diff")).toBe(true);
+			expect(isSafeCommand("git branch")).toBe(true);
+		});
+
+		it("allows npm/yarn read commands", () => {
+			expect(isSafeCommand("npm list")).toBe(true);
+			expect(isSafeCommand("npm outdated")).toBe(true);
+			expect(isSafeCommand("yarn info react")).toBe(true);
+		});
+
+		it("allows other safe commands", () => {
+			expect(isSafeCommand("pwd")).toBe(true);
+			expect(isSafeCommand("echo hello")).toBe(true);
+			expect(isSafeCommand("wc -l file.txt")).toBe(true);
+			expect(isSafeCommand("du -sh .")).toBe(true);
+			expect(isSafeCommand("df -h")).toBe(true);
+		});
+	});
+
+	describe("destructive commands", () => {
+		it("blocks file modification commands", () => {
+			expect(isSafeCommand("rm file.txt")).toBe(false);
+			expect(isSafeCommand("rm -rf dir")).toBe(false);
+			expect(isSafeCommand("mv old new")).toBe(false);
+			expect(isSafeCommand("cp src dst")).toBe(false);
+			expect(isSafeCommand("mkdir newdir")).toBe(false);
+			expect(isSafeCommand("touch newfile")).toBe(false);
+		});
+
+		it("blocks git write commands", () => {
+			expect(isSafeCommand("git add .")).toBe(false);
+			expect(isSafeCommand("git commit -m 'msg'")).toBe(false);
+			expect(isSafeCommand("git push")).toBe(false);
+			expect(isSafeCommand("git checkout main")).toBe(false);
+			expect(isSafeCommand("git reset --hard")).toBe(false);
+		});
+
+		it("blocks package manager installs", () => {
+			expect(isSafeCommand("npm install lodash")).toBe(false);
+			expect(isSafeCommand("yarn add react")).toBe(false);
+			expect(isSafeCommand("pip install requests")).toBe(false);
+			expect(isSafeCommand("brew install node")).toBe(false);
+		});
+
+		it("blocks redirects", () => {
+			expect(isSafeCommand("echo hello > file.txt")).toBe(false);
+			expect(isSafeCommand("cat foo >> bar")).toBe(false);
+			expect(isSafeCommand(">file.txt")).toBe(false);
+		});
+
+		it("blocks dangerous commands", () => {
+			expect(isSafeCommand("sudo rm -rf /")).toBe(false);
+			expect(isSafeCommand("kill -9 1234")).toBe(false);
+			expect(isSafeCommand("reboot")).toBe(false);
+		});
+
+		it("blocks editors", () => {
+			expect(isSafeCommand("vim file.txt")).toBe(false);
+			expect(isSafeCommand("nano file.txt")).toBe(false);
+			expect(isSafeCommand("code .")).toBe(false);
+		});
+	});
+
+	describe("edge cases", () => {
+		it("requires command to be in safe list (not just non-destructive)", () => {
+			expect(isSafeCommand("unknown-command")).toBe(false);
+			expect(isSafeCommand("my-script.sh")).toBe(false);
+		});
+
+		it("handles commands with leading whitespace", () => {
+			expect(isSafeCommand("  ls -la")).toBe(true);
+			expect(isSafeCommand("  rm file")).toBe(false);
+		});
+	});
+});
+
+describe("cleanStepText", () => {
+	it("removes markdown bold/italic", () => {
+		expect(cleanStepText("**bold text**")).toBe("Bold text");
+		expect(cleanStepText("*italic text*")).toBe("Italic text");
+	});
+
+	it("removes markdown code", () => {
+		expect(cleanStepText("run `npm install`")).toBe("Npm install"); // "run" is stripped as action word
+		expect(cleanStepText("check the `config.json` file")).toBe("Config.json file");
+	});
+
+	it("removes leading action words", () => {
+		expect(cleanStepText("Create the new file")).toBe("New file");
+		expect(cleanStepText("Run the tests")).toBe("Tests");
+		expect(cleanStepText("Check the status")).toBe("Status");
+	});
+
+	it("capitalizes first letter", () => {
+		expect(cleanStepText("update config")).toBe("Config");
+	});
+
+	it("truncates long text", () => {
+		const longText = "This is a very long step description that exceeds the maximum allowed length for display";
+		const result = cleanStepText(longText);
+		expect(result.length).toBe(50);
+		expect(result.endsWith("...")).toBe(true);
+	});
+
+	it("normalizes whitespace", () => {
+		expect(cleanStepText("multiple   spaces   here")).toBe("Multiple spaces here");
+	});
+});
+
+describe("extractTodoItems", () => {
+	it("extracts numbered items after Plan: header", () => {
+		const message = `Here's what we'll do:
+
+Plan:
+1. First step here
+2. Second step here
+3. Third step here`;
+
+		const items = extractTodoItems(message);
+		expect(items).toHaveLength(3);
+		expect(items[0].step).toBe(1);
+		expect(items[0].text).toBe("First step here");
+		expect(items[0].completed).toBe(false);
+	});
+
+	it("handles bold Plan header", () => {
+		const message = `**Plan:**
+1. Do something`;
+
+		const items = extractTodoItems(message);
+		expect(items).toHaveLength(1);
+	});
+
+	it("handles parenthesis-style numbering", () => {
+		const message = `Plan:
+1) First item
+2) Second item`;
+
+		const items = extractTodoItems(message);
+		expect(items).toHaveLength(2);
+	});
+
+	it("returns empty array without Plan header", () => {
+		const message = `Here are some steps:
+1. First step
+2. Second step`;
+
+		const items = extractTodoItems(message);
+		expect(items).toHaveLength(0);
+	});
+
+	it("filters out short items", () => {
+		const message = `Plan:
+1. OK
+2. This is a proper step`;
+
+		const items = extractTodoItems(message);
+		expect(items).toHaveLength(1);
+		expect(items[0].text).toContain("proper");
+	});
+
+	it("filters out code-like items", () => {
+		const message = `Plan:
+1. \`npm install\`
+2. Run the build process`;
+
+		const items = extractTodoItems(message);
+		expect(items).toHaveLength(1);
+	});
+});
+
+describe("extractDoneSteps", () => {
+	it("extracts single DONE marker", () => {
+		const message = "I've completed the first step [DONE:1]";
+		expect(extractDoneSteps(message)).toEqual([1]);
+	});
+
+	it("extracts multiple DONE markers", () => {
+		const message = "Did steps [DONE:1] and [DONE:2] and [DONE:3]";
+		expect(extractDoneSteps(message)).toEqual([1, 2, 3]);
+	});
+
+	it("handles case insensitivity", () => {
+		const message = "[done:1] [DONE:2] [Done:3]";
+		expect(extractDoneSteps(message)).toEqual([1, 2, 3]);
+	});
+
+	it("returns empty array with no markers", () => {
+		const message = "No markers here";
+		expect(extractDoneSteps(message)).toEqual([]);
+	});
+
+	it("ignores malformed markers", () => {
+		const message = "[DONE:abc] [DONE:] [DONE:1]";
+		expect(extractDoneSteps(message)).toEqual([1]);
+	});
+});
+
+describe("markCompletedSteps", () => {
+	it("marks matching items as completed", () => {
+		const items: TodoItem[] = [
+			{ step: 1, text: "First", completed: false },
+			{ step: 2, text: "Second", completed: false },
+			{ step: 3, text: "Third", completed: false },
+		];
+
+		const count = markCompletedSteps("[DONE:1] [DONE:3]", items);
+
+		expect(count).toBe(2);
+		expect(items[0].completed).toBe(true);
+		expect(items[1].completed).toBe(false);
+		expect(items[2].completed).toBe(true);
+	});
+
+	it("returns count of completed items", () => {
+		const items: TodoItem[] = [{ step: 1, text: "First", completed: false }];
+
+		expect(markCompletedSteps("[DONE:1]", items)).toBe(1);
+		expect(markCompletedSteps("no markers", items)).toBe(0);
+	});
+
+	it("ignores markers for non-existent steps", () => {
+		const items: TodoItem[] = [{ step: 1, text: "First", completed: false }];
+
+		const count = markCompletedSteps("[DONE:99]", items);
+
+		expect(count).toBe(1); // Still counts the marker found
+		expect(items[0].completed).toBe(false); // But doesn't mark anything
+	});
+
+	it("doesn't double-complete already completed items", () => {
+		const items: TodoItem[] = [{ step: 1, text: "First", completed: true }];
+
+		markCompletedSteps("[DONE:1]", items);
+		expect(items[0].completed).toBe(true);
+	});
+});

package/pi.dev-src/pi-mono/coding-agent/test/print-mode.test.ts

@@ -0,0 +1,140 @@
+import type { AssistantMessage, ImageContent } from "@mariozechner/pi-ai";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import type { SessionShutdownEvent } from "../src/index.js";
+import { runPrintMode } from "../src/modes/print-mode.js";
+
+type EmitEvent = SessionShutdownEvent;
+
+type FakeExtensionRunner = {
+	hasHandlers: (eventType: string) => boolean;
+	emit: ReturnType<typeof vi.fn<(event: EmitEvent) => Promise<void>>>;
+};
+
+type FakeSession = {
+	sessionManager: { getHeader: () => object | undefined };
+	agent: { waitForIdle: () => Promise<void> };
+	state: { messages: AssistantMessage[] };
+	extensionRunner: FakeExtensionRunner;
+	bindExtensions: ReturnType<typeof vi.fn>;
+	subscribe: ReturnType<typeof vi.fn>;
+	prompt: ReturnType<typeof vi.fn>;
+	reload: ReturnType<typeof vi.fn>;
+};
+
+type FakeRuntimeHost = {
+	session: FakeSession;
+	newSession: ReturnType<typeof vi.fn>;
+	fork: ReturnType<typeof vi.fn>;
+	switchSession: ReturnType<typeof vi.fn>;
+	dispose: ReturnType<typeof vi.fn>;
+};
+
+function createAssistantMessage(options?: {
+	text?: string;
+	stopReason?: AssistantMessage["stopReason"];
+	errorMessage?: string;
+}): AssistantMessage {
+	return {
+		role: "assistant",
+		content: options?.text ? [{ type: "text", text: options.text }] : [],
+		api: "openai-responses",
+		provider: "openai",
+		model: "gpt-4o-mini",
+		usage: {
+			input: 0,
+			output: 0,
+			cacheRead: 0,
+			cacheWrite: 0,
+			totalTokens: 0,
+			cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+		},
+		stopReason: options?.stopReason ?? "stop",
+		errorMessage: options?.errorMessage,
+		timestamp: Date.now(),
+	};
+}
+
+function createRuntimeHost(assistantMessage: AssistantMessage): FakeRuntimeHost {
+	const extensionRunner: FakeExtensionRunner = {
+		hasHandlers: (eventType: string) => eventType === "session_shutdown",
+		emit: vi.fn(async () => {}),
+	};
+
+	const state = { messages: [assistantMessage] };
+
+	const session: FakeSession = {
+		sessionManager: { getHeader: () => undefined },
+		agent: { waitForIdle: async () => {} },
+		state,
+		extensionRunner,
+		bindExtensions: vi.fn(async () => {}),
+		subscribe: vi.fn(() => () => {}),
+		prompt: vi.fn(async () => {}),
+		reload: vi.fn(async () => {}),
+	};
+
+	return {
+		session,
+		newSession: vi.fn(async () => undefined),
+		fork: vi.fn(async () => ({ selectedText: "" })),
+		switchSession: vi.fn(async () => undefined),
+		dispose: vi.fn(async () => {
+			await session.extensionRunner.emit({ type: "session_shutdown", reason: "quit" });
+		}),
+	};
+}
+
+afterEach(() => {
+	vi.restoreAllMocks();
+});
+
+describe("runPrintMode", () => {
+	it("emits session_shutdown in text mode", async () => {
+		const runtimeHost = createRuntimeHost(createAssistantMessage({ text: "done" }));
+		const { session } = runtimeHost;
+		const images: ImageContent[] = [{ type: "image", mimeType: "image/png", data: "abc" }];
+
+		const exitCode = await runPrintMode(runtimeHost as unknown as Parameters<typeof runPrintMode>[0], {
+			mode: "text",
+			initialMessage: "Say done",
+			initialImages: images,
+		});
+
+		expect(exitCode).toBe(0);
+		expect(session.prompt).toHaveBeenCalledWith("Say done", { images });
+		expect(session.extensionRunner.emit).toHaveBeenCalledTimes(1);
+		expect(session.extensionRunner.emit).toHaveBeenCalledWith({ type: "session_shutdown", reason: "quit" });
+	});
+
+	it("emits session_shutdown in json mode", async () => {
+		const runtimeHost = createRuntimeHost(createAssistantMessage({ text: "done" }));
+		const { session } = runtimeHost;
+
+		const exitCode = await runPrintMode(runtimeHost as unknown as Parameters<typeof runPrintMode>[0], {
+			mode: "json",
+			messages: ["hello"],
+		});
+
+		expect(exitCode).toBe(0);
+		expect(session.prompt).toHaveBeenCalledWith("hello");
+		expect(session.extensionRunner.emit).toHaveBeenCalledTimes(1);
+		expect(session.extensionRunner.emit).toHaveBeenCalledWith({ type: "session_shutdown", reason: "quit" });
+	});
+
+	it("emits session_shutdown and returns non-zero on assistant error", async () => {
+		const runtimeHost = createRuntimeHost(
+			createAssistantMessage({ stopReason: "error", errorMessage: "provider failure" }),
+		);
+		const { session } = runtimeHost;
+		const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+
+		const exitCode = await runPrintMode(runtimeHost as unknown as Parameters<typeof runPrintMode>[0], {
+			mode: "text",
+		});
+
+		expect(exitCode).toBe(1);
+		expect(errorSpy).toHaveBeenCalledWith("provider failure");
+		expect(session.extensionRunner.emit).toHaveBeenCalledTimes(1);
+		expect(session.extensionRunner.emit).toHaveBeenCalledWith({ type: "session_shutdown", reason: "quit" });
+	});
+});