@oh-my-pi/pi-coding-agent 17.1.5 → 17.1.7

package/src/modes/controllers/extension-ui-controller.test.ts

@@ -1,250 +0,0 @@
-import { afterEach, beforeAll, describe, expect, it, vi } from "bun:test";
-import { Container, setKeybindings } from "@oh-my-pi/pi-tui";
-import { KeybindingsManager } from "../../config/keybindings";
-import type { ExtensionAskDialogQuestion, ExtensionUIContext } from "../../extensibility/extensions";
-import { AskDialogComponent } from "../components/ask-dialog";
-import { CustomEditor } from "../components/custom-editor";
-import { getEditorTheme, getThemeByName, setThemeInstance } from "../theme/theme";
-import type { InteractiveModeContext } from "../types";
-import { ExtensionUiController } from "./extension-ui-controller";
-
-afterEach(() => {
-	setKeybindings(KeybindingsManager.inMemory());
-});
-
-beforeAll(async () => {
-	const dark = await getThemeByName("dark");
-	if (!dark) throw new Error("Failed to load dark theme");
-	setThemeInstance(dark);
-});
-
-function makeHarness() {
-	const editor = new CustomEditor(getEditorTheme());
-	const editorContainer = new Container();
-	editorContainer.addChild(editor);
-	const requestRender = vi.fn();
-	const setFocus = vi.fn();
-	const addAutocompleteProvider = vi.fn();
-	let uiContext: ExtensionUIContext | undefined;
-	const ctx = {
-		editor,
-		ui: {
-			requestRender,
-			setFocus,
-			terminal: { rows: 40 },
-		},
-		editorContainer,
-		session: {
-			extensionRunner: undefined,
-			setUsageFallbackConfirmer: vi.fn(),
-		},
-		setToolUIContext(context: ExtensionUIContext, hasUI: boolean): void {
-			expect(hasUI).toBe(true);
-			uiContext = context;
-		},
-		addAutocompleteProvider,
-	} as unknown as InteractiveModeContext;
-
-	const controller = new ExtensionUiController(ctx);
-
-	return {
-		editor,
-		requestRender,
-		addAutocompleteProvider,
-		editorContainer,
-		setFocus,
-		controller,
-		async init(): Promise<ExtensionUIContext> {
-			await controller.initHooksAndCustomTools();
-			expect(uiContext).toBeDefined();
-			return uiContext!;
-		},
-	};
-}
-
-describe("ExtensionUiController editor UI", () => {
-	it("requests a render after extension pasteToEditor mutates the prompt", async () => {
-		const harness = makeHarness();
-		const ui = await harness.init();
-
-		ui.pasteToEditor("hello");
-		ui.pasteToEditor(" world");
-
-		expect(harness.editor.getText()).toBe("hello world");
-		expect(harness.requestRender).toHaveBeenCalledTimes(2);
-	});
-
-	it("requests a render after extension setEditorText replaces the prompt", async () => {
-		const harness = makeHarness();
-		const ui = await harness.init();
-
-		ui.setEditorText("hello");
-
-		expect(harness.editor.getText()).toBe("hello");
-		expect(harness.requestRender).toHaveBeenCalledTimes(1);
-	});
-
-	it("keeps a populated prompt visible and routes input to it until the draft is cleared", async () => {
-		const harness = makeHarness();
-		harness.editor.setText("finish this wor");
-		const questions: ExtensionAskDialogQuestion[] = [
-			{ id: "confirm", question: "Continue?", options: [{ label: "Yes" }, { label: "No" }] },
-		];
-
-		const pending = harness.controller.showAskDialog(questions);
-		const ask = harness.editorContainer.children[0];
-		expect(ask).toBeInstanceOf(AskDialogComponent);
-		expect(harness.editorContainer.children).toEqual([ask, harness.editor]);
-
-		ask?.handleInput?.("d");
-		expect(harness.editor.getText()).toBe("finish this word");
-
-		harness.editor.setText("");
-		ask?.handleInput?.("\n");
-		expect(await pending).toEqual({
-			kind: "submit",
-			results: [
-				{
-					id: "confirm",
-					question: "Continue?",
-					options: ["Yes", "No"],
-					multi: false,
-					selectedOptions: ["Yes"],
-					customInput: undefined,
-					note: undefined,
-					timedOut: undefined,
-				},
-			],
-		});
-		expect(harness.editorContainer.children).toEqual([harness.editor]);
-	});
-
-	it("does not fire editor-slot shortcuts that would orphan the ask dialog (#6738)", () => {
-		const harness = makeHarness();
-		harness.editor.setText("draft in progress");
-		// Simulate an editor-slot shortcut like the Agent Hub binding, whose
-		// handler clears editorContainer and would strand the pending ask.
-		let hubOpened = false;
-		harness.editor.setCustomKeyHandler("ctrl+s", () => {
-			hubOpened = true;
-			harness.editorContainer.clear();
-		});
-		const questions: ExtensionAskDialogQuestion[] = [
-			{ id: "confirm", question: "Continue?", options: [{ label: "Yes" }, { label: "No" }] },
-		];
-
-		harness.controller.showAskDialog(questions);
-		const ask = harness.editorContainer.children[0];
-		expect(ask).toBeInstanceOf(AskDialogComponent);
-
-		// Ctrl+S reaches the draft editor while ask is open; the shortcut must be
-		// swallowed, the draft untouched, and the ask surface preserved.
-		ask?.handleInput?.("\x13");
-		expect(hubOpened).toBe(false);
-		expect(harness.editor.getText()).toBe("draft in progress");
-		expect(harness.editorContainer.children).toEqual([ask, harness.editor]);
-	});
-
-	it("exposes the draft editor cursor while it proxies input, and drops it once cleared (#6738)", () => {
-		const harness = makeHarness();
-		harness.editor.setText("finish this wor");
-		const questions: ExtensionAskDialogQuestion[] = [
-			{ id: "confirm", question: "Continue?", options: [{ label: "Yes" }, { label: "No" }] },
-		];
-
-		harness.controller.showAskDialog(questions);
-		const ask = harness.editorContainer.children[0];
-		expect(ask).toBeInstanceOf(AskDialogComponent);
-
-		// The ask dialog holds TUI focus, but rendering it must mirror focus onto
-		// the draft editor so its insertion cursor is visible.
-		ask?.render?.(80);
-		expect(harness.editor.focused).toBe(true);
-
-		// Once the draft clears, the ask controls take over and the editor cursor
-		// must not linger.
-		harness.editor.setText("");
-		ask?.render?.(80);
-		expect(harness.editor.focused).toBe(false);
-	});
-
-	it("lets the clear action empty the draft and lift the ask guard (#6738)", () => {
-		const harness = makeHarness();
-		// Route Ctrl+C to the guard: keep app.clear on Ctrl+C but move the ask
-		// cancel key off it, so Ctrl+C reaches draft editing instead of cancelling.
-		setKeybindings(KeybindingsManager.inMemory({ "tui.select.cancel": "ctrl+g" }));
-		harness.editor.setActionKeys("app.clear", ["ctrl+c"]);
-		let cleared = 0;
-		// Mirror interactive wiring: app.clear (Ctrl+C) clears the draft.
-		harness.editor.onClear = () => {
-			cleared++;
-			harness.editor.setText("");
-		};
-		harness.editor.setText("half typed prompt");
-		const questions: ExtensionAskDialogQuestion[] = [
-			{ id: "confirm", question: "Continue?", options: [{ label: "Yes" }, { label: "No" }] },
-		];
-
-		harness.controller.showAskDialog(questions);
-		const ask = harness.editorContainer.children[0];
-		expect(ask).toBeInstanceOf(AskDialogComponent);
-
-		// Ctrl+C is reserved by the base editor and never clears; the guard must
-		// dispatch the configured clear action so the "finish or clear" hint works.
-		ask?.handleInput?.("\x03");
-		expect(cleared).toBe(1);
-		expect(harness.editor.getText()).toBe("");
-
-		// With the draft gone the guard releases: the next key reaches the ask
-		// controls and submits the highlighted option.
-		ask?.handleInput?.("\n");
-		expect(harness.editorContainer.children).toEqual([harness.editor]);
-	});
-
-	it("remounts the draft editor when the ask surface is restored after a nested prompt (#6738)", async () => {
-		const harness = makeHarness();
-		harness.editor.setText("half typed prompt");
-		const questions: ExtensionAskDialogQuestion[] = [
-			{ id: "confirm", question: "Continue?", options: [{ label: "Yes" }, { label: "No" }] },
-		];
-
-		harness.controller.showAskDialog(questions);
-		const ask = harness.editorContainer.children[0];
-		expect(ask).toBeInstanceOf(AskDialogComponent);
-		expect(harness.editorContainer.children).toEqual([ask, harness.editor]);
-
-		// Draft submitted: the guard lifts and ask controls take input; open the
-		// note prompt, which swaps the container to the nested editor.
-		harness.editor.setText("");
-		ask?.handleInput?.("n");
-		const promptEditor = harness.editorContainer.children[0];
-		expect(promptEditor).not.toBe(ask);
-
-		// A failed async submission restores the draft while the nested prompt is
-		// open, re-blocking the guard.
-		harness.editor.setText("half typed prompt");
-
-		// Cancelling the nested prompt restores the ask surface; the draft editor
-		// must be remounted so routed input lands on a visible surface.
-		promptEditor?.handleInput?.("\x1b");
-		expect(harness.editorContainer.children).toEqual([ask, harness.editor]);
-		// The dialog's prompt-active latch clears when the awaited onPrompt
-		// promise settles; yield a microtask before routing the next key.
-		await Promise.resolve();
-		ask?.handleInput?.("!");
-		expect(harness.editor.getText()).toBe("half typed prompt!");
-	});
-
-	it("bridges addAutocompleteProvider factories to the interactive mode context (#4919)", async () => {
-		const harness = makeHarness();
-		const ui = await harness.init();
-
-		expect(typeof ui.addAutocompleteProvider).toBe("function");
-
-		const factory = (current: unknown) => current as never;
-		ui.addAutocompleteProvider(factory);
-
-		expect(harness.addAutocompleteProvider).toHaveBeenCalledTimes(1);
-		expect(harness.addAutocompleteProvider).toHaveBeenCalledWith(factory);
-	});
-});

package/src/modes/noninteractive-dispose.test.ts

@@ -1,73 +0,0 @@
-/**
- * Contract: the print-mode assistant-error/aborted exit path MUST run the
- * awaited `session.dispose()` (which contains the bounded browser reaper
- * `releaseTabsForOwner`) before terminating the process. It previously called
- * `process.exit(1)` ahead of the `dispose()` at the end of `runPrintMode`, so
- * an OMP-owned Chromium survived the exit (issue #5643).
- */
-import { describe, expect, it, spyOn } from "bun:test";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import type { AgentSession } from "../session/agent-session";
-import * as telemetryExport from "../telemetry-export";
-import { runPrintMode } from "./print-mode";
-
-/** Stand-in for `process.exit`: it terminates, so nothing after it should run. */
-class ProcessExit extends Error {
-	constructor(readonly code: number) {
-		super(`process.exit(${code})`);
-	}
-}
-
-describe("print-mode error exit disposes the session before exit", () => {
-	it("disposes on the assistant-error path before process.exit(1)", async () => {
-		const order: string[] = [];
-		const errorMsg: AssistantMessage = {
-			role: "assistant",
-			content: [],
-			api: "openai-responses",
-			provider: "openai",
-			model: "gpt-test",
-			usage: {} as AssistantMessage["usage"],
-			stopReason: "error",
-			errorMessage: "boom",
-			timestamp: 1,
-		};
-		const session = {
-			extensionRunner: undefined,
-			subscribe: () => {},
-			settings: { get: () => false },
-			sessionManager: { buildSessionContext: () => ({ messages: [] }), getEntries: () => [] },
-			state: { messages: [errorMsg] },
-			getLastAssistantMessage: () => errorMsg,
-			prepareForHeadlessAdvisorDrain: () => {},
-			waitForAdvisorCatchup: async () => {
-				order.push("catchup");
-				return true;
-			},
-			dispose: async () => {
-				order.push("dispose");
-			},
-		} as unknown as AgentSession;
-
-		const flushSpy = spyOn(telemetryExport, "flushTelemetryExport").mockImplementation(async () => {
-			order.push("flush");
-		});
-		const exitSpy = spyOn(process, "exit").mockImplementation(((code: number) => {
-			order.push("exit");
-			throw new ProcessExit(code);
-		}) as never);
-		const stderrSpy = spyOn(process.stderr, "write").mockImplementation((() => true) as never);
-
-		try {
-			await runPrintMode(session, { mode: "text" });
-		} catch (err) {
-			if (!(err instanceof ProcessExit)) throw err;
-		} finally {
-			exitSpy.mockRestore();
-			stderrSpy.mockRestore();
-			flushSpy.mockRestore();
-		}
-
-		expect(order).toEqual(["catchup", "flush", "dispose", "exit"]);
-	});
-});

package/src/modes/print-mode.test.ts

@@ -1,71 +0,0 @@
-/**
- * Contract: `--mode json` output stays linear in conversation size. Streaming
- * `message_update` events must not re-serialize the in-progress message, and
- * printed messages must not carry provider-opaque replay payloads (encrypted
- * reasoning history), which previously produced multi-GB transcripts.
- */
-import { describe, expect, it } from "bun:test";
-import type { AssistantMessage } from "@oh-my-pi/pi-ai";
-import type { AgentSessionEvent } from "../session/agent-session";
-import { printableEvent } from "./print-mode";
-
-const assistant: AssistantMessage = {
-	role: "assistant",
-	content: [{ type: "text", text: "hello" }],
-	api: "openai-responses",
-	provider: "openai",
-	model: "gpt-test",
-	usage: {} as AssistantMessage["usage"],
-	stopReason: "stop",
-	timestamp: 1,
-	providerPayload: { type: "openaiResponsesHistory", provider: "openai", dt: true, items: [{ big: "blob" }] },
-};
-
-describe("printableEvent", () => {
-	it("emits only the incremental delta for message_update", () => {
-		const event: AgentSessionEvent = {
-			type: "message_update",
-			message: assistant,
-			assistantMessageEvent: { type: "text_delta", contentIndex: 0, delta: "hel", partial: assistant },
-		};
-		const printed = JSON.parse(JSON.stringify(printableEvent(event)));
-		expect(printed).toEqual({
-			type: "message_update",
-			assistantMessageEvent: { type: "text_delta", contentIndex: 0, delta: "hel" },
-		});
-	});
-
-	it("drops the done-variant message snapshot from message_update", () => {
-		const event: AgentSessionEvent = {
-			type: "message_update",
-			message: assistant,
-			assistantMessageEvent: { type: "done", reason: "stop", message: assistant },
-		};
-		const printed = JSON.parse(JSON.stringify(printableEvent(event)));
-		expect(printed).toEqual({ type: "message_update", assistantMessageEvent: { type: "done", reason: "stop" } });
-	});
-
-	it("strips providerPayload from message_end but keeps the message content", () => {
-		const event: AgentSessionEvent = { type: "message_end", message: assistant };
-		const printed = JSON.parse(JSON.stringify(printableEvent(event))) as {
-			message: Record<string, unknown>;
-		};
-		expect(printed.message.providerPayload).toBeUndefined();
-		expect(printed.message.content).toEqual([{ type: "text", text: "hello" }]);
-		expect(printed.message.model).toBe("gpt-test");
-	});
-
-	it("strips providerPayload from every message in agent_end", () => {
-		const event: AgentSessionEvent = { type: "agent_end", messages: [assistant, assistant] };
-		const printed = JSON.parse(JSON.stringify(printableEvent(event))) as {
-			messages: Array<Record<string, unknown>>;
-		};
-		expect(printed.messages).toHaveLength(2);
-		for (const message of printed.messages) expect(message.providerPayload).toBeUndefined();
-	});
-
-	it("passes unrelated events through untouched", () => {
-		const event: AgentSessionEvent = { type: "notice", level: "info", message: "hi" };
-		expect(printableEvent(event)).toBe(event);
-	});
-});

package/src/modes/session-teardown.test.ts

@@ -1,219 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { postmortem } from "@oh-my-pi/pi-utils";
-import { createSessionTeardown } from "./session-teardown";
-
-/**
- * Signal-safe session teardown contract (issue #4080). The callback body
- * registered on `postmortem` for `SIGINT`/`SIGTERM`/`SIGHUP`/`uncaughtException`
- * must persist the in-progress editor draft and emit the extension
- * `session_shutdown` event (via `session.dispose()`) — the same steps the TUI
- * Ctrl+C keypress path performs. Both paths funnel through
- * `createSessionTeardown`, so exercising it directly proves the acceptance
- * criteria hold regardless of the trigger.
- */
-describe("createSessionTeardown", () => {
-	it("persists the draft, then disposes the session, in that order", async () => {
-		const order: string[] = [];
-		const saved: string[] = [];
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => "unsent draft",
-			beginDispose: () => {
-				order.push("beginDispose");
-			},
-			saveDraft: async text => {
-				order.push("saveDraft");
-				saved.push(text);
-			},
-			disposeSession: async () => {
-				order.push("disposeSession");
-			},
-		});
-
-		await teardown();
-
-		expect(order).toEqual(["beginDispose", "saveDraft", "disposeSession"]);
-		expect(saved).toEqual(["unsent draft"]);
-	});
-
-	it("marks the session disposing before awaiting draft persistence", async () => {
-		const order: string[] = [];
-		const release = Promise.withResolvers<void>();
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => {
-				order.push("snapshot");
-				return "draft";
-			},
-			beginDispose: () => {
-				order.push("beginDispose");
-			},
-			saveDraft: async () => {
-				order.push("saveDraft:start");
-				await release.promise;
-				order.push("saveDraft:done");
-			},
-			disposeSession: async () => {
-				order.push("disposeSession");
-			},
-		});
-
-		const running = teardown();
-		expect(order).toEqual(["snapshot", "beginDispose", "saveDraft:start"]);
-		release.resolve();
-		await running;
-
-		expect(order).toEqual(["snapshot", "beginDispose", "saveDraft:start", "saveDraft:done", "disposeSession"]);
-	});
-
-	it("still disposes when saveDraft rejects — never leaves session_shutdown unemitted", async () => {
-		let disposed = false;
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => "draft",
-			beginDispose: () => {},
-			saveDraft: async () => {
-				throw new Error("disk full");
-			},
-			disposeSession: async () => {
-				disposed = true;
-			},
-		});
-
-		await teardown();
-
-		expect(disposed).toBe(true);
-	});
-
-	it("passes the empty snapshot through so a stale sidecar is cleared on clean exit", async () => {
-		const seen: string[] = [];
-		const teardown = createSessionTeardown({
-			getDraftText: () => "",
-			beginDispose: () => {},
-			saveDraft: async text => {
-				seen.push(text);
-			},
-			disposeSession: async () => {},
-		});
-
-		await teardown();
-
-		expect(seen).toEqual([""]);
-	});
-
-	it("memoizes: concurrent and repeat calls run the teardown exactly once", async () => {
-		let getDraftCalls = 0;
-		let saveDraftCalls = 0;
-		let disposeCalls = 0;
-		const release = Promise.withResolvers<void>();
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => {
-				getDraftCalls++;
-				return `draft-${getDraftCalls}`;
-			},
-			beginDispose: () => {},
-			saveDraft: async () => {
-				saveDraftCalls++;
-			},
-			disposeSession: async () => {
-				disposeCalls++;
-				await release.promise;
-			},
-		});
-
-		// Kick off two concurrent invocations while the first is still awaiting
-		// disposeSession — this is exactly what happens if a SIGTERM arrives
-		// mid-`InteractiveMode.shutdown()`.
-		const first = teardown();
-		const second = teardown();
-		release.resolve();
-		await Promise.all([first, second]);
-
-		// A third call after settlement must still be a no-op.
-		await teardown();
-
-		expect(getDraftCalls).toBe(1);
-		expect(saveDraftCalls).toBe(1);
-		expect(disposeCalls).toBe(1);
-	});
-
-	it("snapshots the draft text at first call — later editor mutations do not leak in", async () => {
-		let editorText = "before";
-		let captured: string | undefined;
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => editorText,
-			beginDispose: () => {},
-			saveDraft: async text => {
-				captured = text;
-			},
-			disposeSession: async () => {},
-		});
-
-		const running = teardown();
-		editorText = "after"; // A late edit must not overwrite the persisted draft.
-		await running;
-
-		expect(captured).toBe("before");
-	});
-
-	it("forwards the postmortem reason into disposeSession so signal exits record the real trigger", async () => {
-		const received: Array<postmortem.Reason | undefined> = [];
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => "",
-			beginDispose: () => {},
-			saveDraft: async () => {},
-			disposeSession: async reason => {
-				received.push(reason);
-			},
-		});
-
-		await teardown(postmortem.Reason.SIGTERM);
-
-		expect(received).toEqual([postmortem.Reason.SIGTERM]);
-	});
-
-	it("keypress path passes no reason — dispose falls back to a normal exit record", async () => {
-		const received: Array<postmortem.Reason | undefined> = [];
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => "",
-			beginDispose: () => {},
-			saveDraft: async () => {},
-			disposeSession: async reason => {
-				received.push(reason);
-			},
-		});
-
-		await teardown();
-
-		expect(received).toEqual([undefined]);
-	});
-
-	it("first call's reason wins: a later caller with a different reason awaits the same promise", async () => {
-		const received: Array<postmortem.Reason | undefined> = [];
-		const release = Promise.withResolvers<void>();
-
-		const teardown = createSessionTeardown({
-			getDraftText: () => "",
-			beginDispose: () => {},
-			saveDraft: async () => {},
-			disposeSession: async reason => {
-				received.push(reason);
-				await release.promise;
-			},
-		});
-
-		// SIGTERM lands first; postmortem.quit(0)'s MANUAL pass arrives while the
-		// teardown is still draining — it must not restart the run or mutate the
-		// recorded reason.
-		const first = teardown(postmortem.Reason.SIGTERM);
-		const second = teardown(postmortem.Reason.MANUAL);
-		release.resolve();
-		await Promise.all([first, second]);
-
-		expect(received).toEqual([postmortem.Reason.SIGTERM]);
-	});
-});

package/src/modes/theme/mermaid-rendering.test.ts

@@ -1,53 +0,0 @@
-import { afterEach, beforeAll, describe, expect, it } from "bun:test";
-import { Markdown } from "@oh-my-pi/pi-tui";
-import { Settings } from "../../config/settings";
-import { buildSystemPrompt } from "../../system-prompt";
-import { getMarkdownTheme, getThemeByName, setMarkdownMermaidRendering, setThemeInstance } from "./theme";
-
-const workspaceTree = {
-	rootPath: "/tmp/project",
-	rendered: "",
-	truncated: false,
-	totalLines: 0,
-	agentsMdFiles: [],
-};
-
-function stripAnsi(text: string): string {
-	return text.replace(/\x1b\[[0-9;]*m/g, "");
-}
-
-beforeAll(async () => {
-	await Settings.init({ inMemory: true });
-	const theme = await getThemeByName("dark");
-	if (!theme) throw new Error("theme unavailable");
-	setThemeInstance(theme);
-});
-
-afterEach(() => {
-	setMarkdownMermaidRendering(true);
-});
-
-describe("Mermaid rendering setting", () => {
-	it("removes the Mermaid prompt note when rendering is disabled", async () => {
-		const { systemPrompt } = await buildSystemPrompt({
-			renderMermaid: false,
-			contextFiles: [],
-			skills: [],
-			toolNames: [],
-			workspaceTree,
-		});
-
-		expect(systemPrompt.join("\n")).not.toContain("```mermaid");
-	});
-
-	it("falls back to a highlighted code fence when rendering is disabled", () => {
-		setMarkdownMermaidRendering(false);
-
-		const markdown = new Markdown("```mermaid\ngraph TD\n  A --> B\n```", 0, 0, getMarkdownTheme());
-		const lines = stripAnsi(markdown.render(80).join("\n"));
-
-		expect(lines).toContain("```mermaid");
-		expect(lines).toContain("graph TD");
-		expect(lines).toContain("-->");
-	});
-});