@oh-my-pi/pi-coding-agent 5.6.77 → 5.7.68

package/src/core/python-executor.lifecycle.test.ts

@@ -1,139 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { disposeAllKernelSessions, executePython } from "./python-executor";
-import { type KernelExecuteOptions, type KernelExecuteResult, PythonKernel } from "./python-kernel";
-
-process.env.OMP_PYTHON_SKIP_CHECK = "1";
-
-class FakeKernel {
-	private result: KernelExecuteResult;
-	private onExecute?: (options?: KernelExecuteOptions) => void;
-	private alive: boolean;
-	readonly executeCalls: string[] = [];
-	shutdownCalls = 0;
-
-	constructor(
-		result: KernelExecuteResult,
-		options: { alive?: boolean; onExecute?: (options?: KernelExecuteOptions) => void } = {},
-	) {
-		this.result = result;
-		this.onExecute = options.onExecute;
-		this.alive = options.alive ?? true;
-	}
-
-	isAlive(): boolean {
-		return this.alive;
-	}
-
-	async execute(code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
-		this.executeCalls.push(code);
-		this.onExecute?.(options);
-		return this.result;
-	}
-
-	async shutdown(): Promise<void> {
-		this.shutdownCalls += 1;
-		this.alive = false;
-	}
-
-	async ping(): Promise<boolean> {
-		return this.alive;
-	}
-}
-
-const okResult: KernelExecuteResult = {
-	status: "ok",
-	cancelled: false,
-	timedOut: false,
-	stdinRequested: false,
-};
-
-describe("executePython session lifecycle", () => {
-	const originalStart = PythonKernel.start;
-
-	afterEach(async () => {
-		PythonKernel.start = originalStart;
-		await disposeAllKernelSessions();
-	});
-
-	it("reuses a session kernel across calls", async () => {
-		let startCount = 0;
-		const kernel = new FakeKernel(okResult, { onExecute: (options) => options?.onChunk?.("ok\n") });
-		PythonKernel.start = async () => {
-			startCount += 1;
-			return kernel as unknown as PythonKernel;
-		};
-
-		const first = await executePython("print('one')", { sessionId: "session-1" });
-		const second = await executePython("print('two')", { sessionId: "session-1" });
-
-		expect(startCount).toBe(1);
-		expect(kernel.executeCalls).toEqual(["print('one')", "print('two')"]);
-		expect(first.output).toContain("ok");
-		expect(second.output).toContain("ok");
-	});
-
-	it("restarts the session kernel when not alive", async () => {
-		const deadKernel = new FakeKernel(okResult, { alive: false });
-		const liveKernel = new FakeKernel(okResult, { onExecute: (options) => options?.onChunk?.("live\n") });
-		const kernels = [deadKernel, liveKernel];
-		let startCount = 0;
-
-		PythonKernel.start = async () => {
-			startCount += 1;
-			return kernels.shift() as unknown as PythonKernel;
-		};
-
-		const result = await executePython("print('restart')", { sessionId: "session-restart" });
-
-		expect(startCount).toBe(2);
-		expect(deadKernel.shutdownCalls).toBe(1);
-		expect(deadKernel.executeCalls).toEqual([]);
-		expect(liveKernel.executeCalls).toEqual(["print('restart')"]);
-		expect(result.output).toContain("live");
-	});
-
-	it("resets the session kernel when requested", async () => {
-		const firstKernel = new FakeKernel(okResult);
-		const secondKernel = new FakeKernel(okResult);
-		const kernels = [firstKernel, secondKernel];
-		let startCount = 0;
-
-		PythonKernel.start = async () => {
-			startCount += 1;
-			return kernels.shift() as unknown as PythonKernel;
-		};
-
-		await executePython("print('one')", { sessionId: "session-reset" });
-		await executePython("print('two')", { sessionId: "session-reset", reset: true });
-
-		expect(startCount).toBe(2);
-		expect(firstKernel.shutdownCalls).toBe(1);
-		expect(secondKernel.executeCalls).toEqual(["print('two')"]);
-	});
-
-	it("uses per-call kernels when configured", async () => {
-		const kernelA = new FakeKernel(okResult);
-		const kernelB = new FakeKernel(okResult);
-		const kernels = [kernelA, kernelB];
-		let startCount = 0;
-		let shutdownCount = 0;
-
-		PythonKernel.start = async () => {
-			startCount += 1;
-			return kernels.shift() as unknown as PythonKernel;
-		};
-
-		kernelA.shutdown = async () => {
-			shutdownCount += 1;
-		};
-		kernelB.shutdown = async () => {
-			shutdownCount += 1;
-		};
-
-		await executePython("print('one')", { kernelMode: "per-call" });
-		await executePython("print('two')", { kernelMode: "per-call" });
-
-		expect(startCount).toBe(2);
-		expect(shutdownCount).toBe(2);
-	});
-});

package/src/core/python-executor.result.test.ts

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
-import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
-
-class FakeKernel implements PythonKernelExecutor {
-	private result: KernelExecuteResult;
-	private onExecute?: (options?: KernelExecuteOptions) => void;
-
-	constructor(result: KernelExecuteResult, onExecute?: (options?: KernelExecuteOptions) => void) {
-		this.result = result;
-		this.onExecute = onExecute;
-	}
-
-	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
-		this.onExecute?.(options);
-		return this.result;
-	}
-}
-
-describe("executePythonWithKernel result mapping", () => {
-	it("adds timeout annotation when cancelled", async () => {
-		const kernel = new FakeKernel({
-			status: "ok",
-			cancelled: true,
-			timedOut: true,
-			stdinRequested: false,
-		});
-
-		const result = await executePythonWithKernel(kernel, "sleep()", { timeout: 5000 });
-
-		expect(result.exitCode).toBeUndefined();
-		expect(result.cancelled).toBe(true);
-		expect(result.output).toContain("Command timed out after 5 seconds");
-	});
-
-	it("maps kernel error status to exit code 1", async () => {
-		const kernel = new FakeKernel(
-			{ status: "error", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("Traceback...\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "raise ValueError('boom')");
-
-		expect(result.exitCode).toBe(1);
-		expect(result.output).toContain("Traceback");
-	});
-});

package/src/core/python-executor.test.ts

@@ -1,180 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import { rmSync } from "node:fs";
-import {
-	disposeAllKernelSessions,
-	executePythonWithKernel,
-	getPreludeDocs,
-	type PythonKernelExecutor,
-	resetPreludeDocsCache,
-	warmPythonEnvironment,
-} from "./python-executor";
-import { type KernelExecuteOptions, type KernelExecuteResult, type PreludeHelper, PythonKernel } from "./python-kernel";
-import { DEFAULT_MAX_BYTES } from "./tools/truncate";
-
-class FakeKernel implements PythonKernelExecutor {
-	private result: KernelExecuteResult;
-	private onExecute: (options?: KernelExecuteOptions) => void;
-
-	constructor(result: KernelExecuteResult, onExecute: (options?: KernelExecuteOptions) => void) {
-		this.result = result;
-		this.onExecute = onExecute;
-	}
-
-	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
-		this.onExecute(options);
-		return this.result;
-	}
-}
-
-describe("executePythonWithKernel", () => {
-	it("captures text and display outputs", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("hello\n");
-				options?.onDisplay?.({ type: "json", data: { foo: "bar" } });
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "print('hello')");
-
-		expect(result.exitCode).toBe(0);
-		expect(result.output).toContain("hello");
-		expect(result.displayOutputs).toHaveLength(1);
-	});
-
-	it("marks stdin request as error", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: true },
-			() => {},
-		);
-
-		const result = await executePythonWithKernel(kernel, "input('prompt')");
-
-		expect(result.exitCode).toBe(1);
-		expect(result.stdinRequested).toBe(true);
-		expect(result.output).toContain("Kernel requested stdin; interactive input is not supported.");
-	});
-
-	it("maps error status to exit code 1", async () => {
-		const kernel = new FakeKernel(
-			{ status: "error", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("Traceback\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "raise ValueError('nope')");
-
-		expect(result.exitCode).toBe(1);
-		expect(result.cancelled).toBe(false);
-		expect(result.output).toContain("Traceback");
-	});
-
-	it("sanitizes streamed chunks", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("\u001b[31mred\r\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "print('red')");
-
-		expect(result.output).toBe("red\n");
-	});
-
-	it("returns cancelled result with timeout annotation", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: true, timedOut: true, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("partial output\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "while True: pass", { timeout: 4100 });
-
-		expect(result.exitCode).toBeUndefined();
-		expect(result.cancelled).toBe(true);
-		expect(result.output).toContain("Command timed out after 4 seconds");
-	});
-
-	it("returns cancelled result without timeout annotation", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: true, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("cancelled output\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "while True: pass");
-
-		expect(result.exitCode).toBeUndefined();
-		expect(result.cancelled).toBe(true);
-		expect(result.output).toContain("cancelled output");
-		expect(result.output).not.toContain("Command timed out");
-	});
-
-	it("truncates large output and stores full output file", async () => {
-		const largeOutput = `${"x".repeat(DEFAULT_MAX_BYTES + 1024)}TAIL`;
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.(largeOutput);
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "print('big')");
-
-		expect(result.truncated).toBe(true);
-		expect(result.fullOutputPath).toBeDefined();
-		expect(result.output).toContain("TAIL");
-
-		const fullText = await Bun.file(result.fullOutputPath as string).text();
-		expect(fullText).toBe(largeOutput);
-
-		rmSync(result.fullOutputPath as string, { force: true });
-	});
-});
-
-afterEach(async () => {
-	await disposeAllKernelSessions();
-	resetPreludeDocsCache();
-	vi.restoreAllMocks();
-});
-
-describe("warmPythonEnvironment", () => {
-	it("caches prelude docs on warmup", async () => {
-		const previousSkip = process.env.OMP_PYTHON_SKIP_CHECK;
-		process.env.OMP_PYTHON_SKIP_CHECK = "1";
-		const docs: PreludeHelper[] = [
-			{
-				name: "read",
-				signature: "(path)",
-				docstring: "Read file contents.",
-				category: "File I/O",
-			},
-		];
-		const kernel = {
-			introspectPrelude: vi.fn().mockResolvedValue(docs),
-			ping: vi.fn().mockResolvedValue(true),
-			isAlive: () => true,
-			shutdown: vi.fn().mockResolvedValue(undefined),
-		};
-		const startSpy = vi.spyOn(PythonKernel, "start").mockResolvedValue(kernel as unknown as PythonKernel);
-
-		const result = await warmPythonEnvironment("/tmp/test", "session-1");
-
-		expect(result.ok).toBe(true);
-		expect(result.docs).toEqual(docs);
-		expect(getPreludeDocs()).toEqual(docs);
-		expect(kernel.introspectPrelude).toHaveBeenCalledTimes(1);
-
-		startSpy.mockRestore();
-		if (previousSkip === undefined) {
-			delete process.env.OMP_PYTHON_SKIP_CHECK;
-		} else {
-			process.env.OMP_PYTHON_SKIP_CHECK = previousSkip;
-		}
-	});
-});

package/src/core/python-kernel-display.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { type KernelDisplayOutput, PythonKernel } from "./python-kernel";
-
-const renderDisplay = (
-	PythonKernel as unknown as {
-		prototype: {
-			renderDisplay: (content: Record<string, unknown>) => {
-				text: string;
-				outputs: KernelDisplayOutput[];
-			};
-		};
-	}
-).prototype.renderDisplay;
-
-describe("PythonKernel display rendering", () => {
-	it("normalizes text/plain output and returns no display outputs", () => {
-		const { text, outputs } = renderDisplay.call({} as PythonKernel, {
-			data: { "text/plain": "hello" },
-		});
-
-		expect(text).toBe("hello\n");
-		expect(outputs).toHaveLength(0);
-	});
-
-	it("collects image and json display outputs without text", () => {
-		const { text, outputs } = renderDisplay.call({} as PythonKernel, {
-			data: { "image/png": "abc", "application/json": { foo: "bar" } },
-		});
-
-		expect(text).toBe("");
-		expect(outputs).toEqual([
-			{ type: "image", data: "abc", mimeType: "image/png" },
-			{ type: "json", data: { foo: "bar" } },
-		]);
-	});
-
-	it("converts text/html to markdown", () => {
-		const { text, outputs } = renderDisplay.call({} as PythonKernel, {
-			data: { "text/html": "<p><strong>Hello</strong></p>" },
-		});
-
-		expect(outputs).toHaveLength(0);
-		expect(text).toBe("**Hello**\n");
-	});
-
-	it("combines text/plain with json output", () => {
-		const { text, outputs } = renderDisplay.call({} as PythonKernel, {
-			data: { "text/plain": "value", "application/json": { ok: true } },
-		});
-
-		expect(text).toBe("value\n");
-		expect(outputs).toEqual([{ type: "json", data: { ok: true } }]);
-	});
-});

package/src/core/python-kernel-env.test.ts

@@ -1,138 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "bun:test";
-import * as shell from "../utils/shell";
-import * as shellSnapshot from "../utils/shell-snapshot";
-import { PythonKernel } from "./python-kernel";
-import { PYTHON_PRELUDE } from "./python-prelude";
-
-class FakeWebSocket {
-	static OPEN = 1;
-	static CLOSED = 3;
-	readyState = FakeWebSocket.OPEN;
-	binaryType = "arraybuffer";
-	url: string;
-	onopen?: () => void;
-	onerror?: (event: unknown) => void;
-	onclose?: () => void;
-	onmessage?: (event: { data: ArrayBuffer }) => void;
-
-	constructor(url: string) {
-		this.url = url;
-		queueMicrotask(() => {
-			this.onopen?.();
-		});
-	}
-
-	send(_data: ArrayBuffer) {}
-
-	close() {
-		this.readyState = FakeWebSocket.CLOSED;
-		this.onclose?.();
-	}
-}
-
-describe("PythonKernel.start (local gateway)", () => {
-	const originalEnv = { ...process.env };
-	const originalFetch = globalThis.fetch;
-	const originalWebSocket = globalThis.WebSocket;
-
-	beforeEach(() => {
-		process.env.BUN_ENV = "test";
-		delete process.env.OMP_PYTHON_GATEWAY_URL;
-		delete process.env.OMP_PYTHON_GATEWAY_TOKEN;
-		globalThis.WebSocket = FakeWebSocket as unknown as typeof WebSocket;
-	});
-
-	afterEach(() => {
-		for (const key of Object.keys(process.env)) {
-			if (!(key in originalEnv)) {
-				delete process.env[key];
-			}
-		}
-		for (const [key, value] of Object.entries(originalEnv)) {
-			process.env[key] = value;
-		}
-		globalThis.fetch = originalFetch;
-		globalThis.WebSocket = originalWebSocket;
-		vi.restoreAllMocks();
-	});
-
-	it("filters environment variables before spawning gateway", async () => {
-		const fetchSpy = vi.fn(async (input: string | URL, init?: RequestInit) => {
-			const url = typeof input === "string" ? input : input.toString();
-			if (url.endsWith("/api/kernelspecs")) {
-				return new Response(JSON.stringify({}), { status: 200 });
-			}
-			if (url.endsWith("/api/kernels") && init?.method === "POST") {
-				return new Response(JSON.stringify({ id: "kernel-1" }), { status: 201 });
-			}
-			return new Response("", { status: 200 });
-		});
-		globalThis.fetch = fetchSpy as unknown as typeof fetch;
-
-		const shellSpy = vi.spyOn(shell, "getShellConfig").mockResolvedValue({
-			shell: "/bin/bash",
-			args: ["-lc"],
-			env: {
-				PATH: "/bin",
-				HOME: "/home/test",
-				OPENAI_API_KEY: "secret",
-				UNSAFE_TOKEN: "nope",
-				OMP_CUSTOM: "1",
-				LC_ALL: "en_US.UTF-8",
-			},
-			prefix: undefined,
-		});
-		const snapshotSpy = vi.spyOn(shellSnapshot, "getOrCreateSnapshot").mockResolvedValue(null);
-		const whichSpy = vi.spyOn(Bun, "which").mockReturnValue("/usr/bin/python");
-
-		let spawnEnv: Record<string, string | undefined> | undefined;
-		let spawnArgs: string[] | undefined;
-		const spawnSpy = vi.spyOn(Bun, "spawn").mockImplementation(((...args: unknown[]) => {
-			const [cmd, options] = args as [string[] | { cmd: string[] }, { env?: Record<string, string | undefined> }?];
-			spawnArgs = Array.isArray(cmd) ? cmd : cmd.cmd;
-			spawnEnv = options?.env;
-			return { pid: 1234, exited: Promise.resolve(0) } as unknown as Bun.Subprocess;
-		}) as unknown as typeof Bun.spawn);
-
-		const executeSpy = vi
-			.spyOn(PythonKernel.prototype, "execute")
-			.mockResolvedValue({ status: "ok", cancelled: false, timedOut: false, stdinRequested: false });
-
-		const kernel = await PythonKernel.start({ cwd: "/tmp/project", env: { CUSTOM_VAR: "ok" } });
-
-		const createCall = fetchSpy.mock.calls.find(([input, init]) => {
-			const url = typeof input === "string" ? input : input.toString();
-			return url.endsWith("/api/kernels") && init?.method === "POST";
-		});
-		expect(createCall).toBeDefined();
-		if (createCall) {
-			expect(JSON.parse(String(createCall[1]?.body ?? "{}"))).toEqual({ name: "python3" });
-		}
-
-		expect(spawnArgs).toContain("kernel_gateway");
-		expect(spawnEnv?.PATH).toBe("/bin");
-		expect(spawnEnv?.HOME).toBe("/home/test");
-		expect(spawnEnv?.OMP_CUSTOM).toBe("1");
-		expect(spawnEnv?.LC_ALL).toBe("en_US.UTF-8");
-		expect(spawnEnv?.CUSTOM_VAR).toBe("ok");
-		expect(spawnEnv?.OPENAI_API_KEY).toBeUndefined();
-		expect(spawnEnv?.UNSAFE_TOKEN).toBeUndefined();
-		expect(spawnEnv?.PYTHONPATH).toBe("/tmp/project");
-
-		expect(executeSpy).toHaveBeenCalledWith(
-			PYTHON_PRELUDE,
-			expect.objectContaining({
-				silent: true,
-				storeHistory: false,
-			}),
-		);
-
-		await kernel.shutdown();
-
-		shellSpy.mockRestore();
-		snapshotSpy.mockRestore();
-		whichSpy.mockRestore();
-		spawnSpy.mockRestore();
-		executeSpy.mockRestore();
-	});
-});

package/src/core/python-kernel-session.test.ts

@@ -1,87 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it } from "bun:test";
-import { disposeAllKernelSessions, executePython } from "./python-executor";
-import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
-import { PythonKernel } from "./python-kernel";
-
-class FakeKernel {
-	executeCalls = 0;
-	shutdownCalls = 0;
-	alive = true;
-	readonly id: string;
-
-	constructor(id: string) {
-		this.id = id;
-	}
-
-	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
-		this.executeCalls += 1;
-		options?.onChunk?.("ok\n");
-		return { status: "ok", cancelled: false, timedOut: false, stdinRequested: false };
-	}
-
-	async shutdown(): Promise<void> {
-		this.shutdownCalls += 1;
-		this.alive = false;
-	}
-
-	isAlive(): boolean {
-		return this.alive;
-	}
-
-	async ping(): Promise<boolean> {
-		return this.alive;
-	}
-}
-
-describe("executePython kernel reuse", () => {
-	const originalStart = PythonKernel.start;
-	let startCalls = 0;
-	let kernels: FakeKernel[] = [];
-
-	beforeEach(() => {
-		process.env.OMP_PYTHON_SKIP_CHECK = "1";
-		startCalls = 0;
-		kernels = [];
-		PythonKernel.start = (async () => {
-			startCalls += 1;
-			const kernel = new FakeKernel(`kernel-${startCalls}`);
-			kernels.push(kernel);
-			return kernel as unknown as PythonKernel;
-		}) as typeof PythonKernel.start;
-	});
-
-	afterEach(async () => {
-		PythonKernel.start = originalStart;
-		await disposeAllKernelSessions();
-	});
-
-	it("reuses kernels for session mode", async () => {
-		await executePython("print('one')", { cwd: "/tmp", sessionId: "session-a", kernelMode: "session" });
-		await executePython("print('two')", { cwd: "/tmp", sessionId: "session-a", kernelMode: "session" });
-
-		expect(startCalls).toBe(1);
-		expect(kernels[0]?.executeCalls).toBe(2);
-	});
-
-	it("creates and disposes per-call kernels", async () => {
-		await executePython("print('one')", { cwd: "/tmp", kernelMode: "per-call" });
-		await executePython("print('two')", { cwd: "/tmp", kernelMode: "per-call" });
-
-		expect(startCalls).toBe(2);
-		expect(kernels[0]?.shutdownCalls).toBe(1);
-		expect(kernels[1]?.shutdownCalls).toBe(1);
-	});
-
-	it("resets the session kernel when requested", async () => {
-		await executePython("print('one')", { cwd: "/tmp", sessionId: "session-b", kernelMode: "session" });
-		await executePython("print('two')", {
-			cwd: "/tmp",
-			sessionId: "session-b",
-			kernelMode: "session",
-			reset: true,
-		});
-
-		expect(startCalls).toBe(2);
-		expect(kernels[0]?.shutdownCalls).toBe(1);
-	});
-});