@oh-my-pi/pi-coding-agent 5.7.67 → 5.7.69

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

@@ -1,42 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
-import type { KernelDisplayOutput, KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
-
-class FakeKernel implements PythonKernelExecutor {
-	private result: KernelExecuteResult;
-	private onExecute: (options?: KernelExecuteOptions) => Promise<void> | void;
-
-	constructor(result: KernelExecuteResult, onExecute: (options?: KernelExecuteOptions) => Promise<void> | void) {
-		this.result = result;
-		this.onExecute = onExecute;
-	}
-
-	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
-		await this.onExecute(options);
-		return this.result;
-	}
-}
-
-describe("executePythonWithKernel display outputs", () => {
-	it("aggregates display outputs in order", async () => {
-		const outputs: KernelDisplayOutput[] = [
-			{ type: "json", data: { foo: "bar" } },
-			{ type: "image", data: "abc", mimeType: "image/png" },
-		];
-
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
-			async (options) => {
-				if (!options?.onDisplay) return;
-				for (const output of outputs) {
-					await options.onDisplay(output);
-				}
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "print('hi')");
-
-		expect(result.exitCode).toBe(0);
-		expect(result.displayOutputs).toEqual(outputs);
-	});
-});

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

@@ -1,99 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import { disposeAllKernelSessions, executePython } from "./python-executor";
-import type { KernelExecuteResult } from "./python-kernel";
-import * as pythonKernel from "./python-kernel";
-
-class FakeKernel {
-	execute = vi.fn(async () => this.result);
-	shutdown = vi.fn(async () => {});
-	ping = vi.fn(async () => true);
-	alive = true;
-
-	constructor(private readonly result: KernelExecuteResult) {}
-
-	isAlive(): boolean {
-		return this.alive;
-	}
-}
-
-const OK_RESULT: KernelExecuteResult = {
-	status: "ok",
-	cancelled: false,
-	timedOut: false,
-	stdinRequested: false,
-};
-
-afterEach(async () => {
-	vi.restoreAllMocks();
-	await disposeAllKernelSessions();
-});
-
-describe("executePython lifecycle", () => {
-	it("starts and shuts down per-call kernels", async () => {
-		const kernel = new FakeKernel(OK_RESULT);
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi
-			.spyOn(pythonKernel.PythonKernel, "start")
-			.mockResolvedValue(kernel as unknown as pythonKernel.PythonKernel);
-
-		await executePython("print('hi')", { kernelMode: "per-call", cwd: process.cwd() });
-
-		expect(startSpy).toHaveBeenCalledTimes(1);
-		expect(kernel.execute).toHaveBeenCalledTimes(1);
-		expect(kernel.shutdown).toHaveBeenCalledTimes(1);
-	});
-
-	it("reuses session kernels until reset", async () => {
-		const kernel = new FakeKernel(OK_RESULT);
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi
-			.spyOn(pythonKernel.PythonKernel, "start")
-			.mockResolvedValue(kernel as unknown as pythonKernel.PythonKernel);
-
-		await executePython("1 + 1", { kernelMode: "session", sessionId: "test-session", cwd: process.cwd() });
-		await executePython("2 + 2", { kernelMode: "session", sessionId: "test-session", cwd: process.cwd() });
-
-		expect(startSpy).toHaveBeenCalledTimes(1);
-		expect(kernel.execute).toHaveBeenCalledTimes(2);
-	});
-
-	it("resets session kernels when requested", async () => {
-		const kernel = new FakeKernel(OK_RESULT);
-		const kernelNext = new FakeKernel(OK_RESULT);
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi
-			.spyOn(pythonKernel.PythonKernel, "start")
-			.mockResolvedValueOnce(kernel as unknown as pythonKernel.PythonKernel)
-			.mockResolvedValueOnce(kernelNext as unknown as pythonKernel.PythonKernel);
-
-		await executePython("1 + 1", { kernelMode: "session", sessionId: "reset-session", cwd: process.cwd() });
-		await executePython("2 + 2", {
-			kernelMode: "session",
-			sessionId: "reset-session",
-			reset: true,
-			cwd: process.cwd(),
-		});
-
-		expect(startSpy).toHaveBeenCalledTimes(2);
-		expect(kernel.shutdown).toHaveBeenCalledTimes(1);
-		expect(kernelNext.execute).toHaveBeenCalledTimes(1);
-	});
-
-	it("restarts session kernels when they are dead", async () => {
-		const kernel = new FakeKernel(OK_RESULT);
-		const kernelNext = new FakeKernel(OK_RESULT);
-		kernel.alive = false;
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi
-			.spyOn(pythonKernel.PythonKernel, "start")
-			.mockResolvedValueOnce(kernel as unknown as pythonKernel.PythonKernel)
-			.mockResolvedValueOnce(kernelNext as unknown as pythonKernel.PythonKernel);
-
-		await executePython("1 + 1", { kernelMode: "session", sessionId: "dead-session", cwd: process.cwd() });
-
-		expect(startSpy).toHaveBeenCalledTimes(2);
-		expect(kernel.shutdown).toHaveBeenCalledTimes(1);
-		expect(kernel.execute).toHaveBeenCalledTimes(0);
-		expect(kernelNext.execute).toHaveBeenCalledTimes(1);
-	});
-});

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

@@ -1,41 +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 {
-	constructor(
-		private result: KernelExecuteResult,
-		private onExecute: (options?: KernelExecuteOptions) => void = () => {},
-	) {}
-
-	async execute(_code: string, options?: KernelExecuteOptions): Promise<KernelExecuteResult> {
-		this.onExecute(options);
-		return this.result;
-	}
-}
-
-describe("executePythonWithKernel mapping", () => {
-	it("annotates timeout cancellations", async () => {
-		const kernel = new FakeKernel({ status: "ok", cancelled: true, timedOut: true, stdinRequested: false });
-		const result = await executePythonWithKernel(kernel, "sleep(10)", { timeout: 5000 });
-
-		expect(result.cancelled).toBe(true);
-		expect(result.exitCode).toBeUndefined();
-		expect(result.output).toContain("Command timed out after 5 seconds");
-	});
-
-	it("maps error status to non-zero exit code", async () => {
-		const kernel = new FakeKernel(
-			{ status: "error", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("traceback\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "1 / 0");
-
-		expect(result.exitCode).toBe(1);
-		expect(result.output).toContain("traceback");
-		expect(result.stdinRequested).toBe(false);
-	});
-});

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

@@ -1,49 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { executePython } from "./python-executor";
-import type { KernelExecuteOptions, KernelExecuteResult } from "./python-kernel";
-import { PythonKernel } from "./python-kernel";
-
-interface KernelStub {
-	execute: (code: string, options?: KernelExecuteOptions) => Promise<KernelExecuteResult>;
-	shutdown: () => Promise<void>;
-}
-
-describe("executePython (per-call)", () => {
-	it("shuts down kernel on timed-out cancellation", async () => {
-		process.env.OMP_PYTHON_SKIP_CHECK = "1";
-
-		let shutdownCalls = 0;
-		const kernel: KernelStub = {
-			execute: async () => ({
-				status: "ok",
-				cancelled: true,
-				timedOut: true,
-				stdinRequested: false,
-			}),
-			shutdown: async () => {
-				shutdownCalls += 1;
-			},
-		};
-
-		const kernelClass = PythonKernel as unknown as {
-			start: (options: { cwd: string }) => Promise<KernelStub>;
-		};
-		const originalStart = kernelClass.start;
-		kernelClass.start = async () => kernel;
-
-		try {
-			const result = await executePython("sleep(10)", {
-				kernelMode: "per-call",
-				timeout: 2000,
-				cwd: "/tmp",
-			});
-
-			expect(result.cancelled).toBe(true);
-			expect(result.exitCode).toBeUndefined();
-			expect(result.output).toContain("Command timed out after 2 seconds");
-			expect(shutdownCalls).toBe(1);
-		} finally {
-			kernelClass.start = originalStart;
-		}
-	});
-});

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

@@ -1,103 +0,0 @@
-import { afterEach, describe, expect, it, vi } from "bun:test";
-import { disposeAllKernelSessions, executePython } from "./python-executor";
-import * as pythonKernel from "./python-kernel";
-
-class FakeKernel {
-	executeCalls = 0;
-	shutdownCalls = 0;
-	alive = true;
-	constructor(private readonly shouldThrow: boolean = false) {}
-
-	isAlive(): boolean {
-		return this.alive;
-	}
-
-	async execute(): Promise<{ status: "ok"; cancelled: false; timedOut: false; stdinRequested: false }> {
-		this.executeCalls += 1;
-		if (this.shouldThrow) {
-			this.alive = false;
-			throw new Error("kernel crashed");
-		}
-		return { status: "ok", cancelled: false, timedOut: false, stdinRequested: false };
-	}
-
-	async ping(): Promise<boolean> {
-		return this.alive;
-	}
-
-	async shutdown(): Promise<void> {
-		this.shutdownCalls += 1;
-		this.alive = false;
-	}
-}
-
-describe("executePython session lifecycle", () => {
-	afterEach(async () => {
-		vi.restoreAllMocks();
-		await disposeAllKernelSessions();
-	});
-
-	it("restarts session when kernel is not alive", async () => {
-		const kernel1 = new FakeKernel();
-		kernel1.alive = false;
-		const kernel2 = new FakeKernel();
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi
-			.spyOn(pythonKernel.PythonKernel, "start")
-			.mockResolvedValueOnce(kernel1 as unknown as pythonKernel.PythonKernel)
-			.mockResolvedValueOnce(kernel2 as unknown as pythonKernel.PythonKernel);
-
-		await executePython("print('hi')", { cwd: "/tmp", sessionId: "session-1", kernelMode: "session" });
-
-		expect(startSpy).toHaveBeenCalledTimes(2);
-		expect(kernel1.executeCalls).toBe(0);
-		expect(kernel1.shutdownCalls).toBe(1);
-		expect(kernel2.executeCalls).toBe(1);
-	});
-
-	it("restarts after an execution failure when kernel is dead", async () => {
-		const kernel1 = new FakeKernel(true);
-		const kernel2 = new FakeKernel();
-		const starts = [kernel1, kernel2];
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi.spyOn(pythonKernel.PythonKernel, "start").mockImplementation(async () => {
-			const next = starts.shift();
-			if (!next) {
-				throw new Error("No kernel available");
-			}
-			return next as unknown as pythonKernel.PythonKernel;
-		});
-
-		await executePython("raise", { cwd: "/tmp", sessionId: "session-2", kernelMode: "session" });
-
-		expect(startSpy).toHaveBeenCalledTimes(2);
-		expect(kernel1.executeCalls).toBe(1);
-		expect(kernel2.executeCalls).toBe(1);
-	});
-
-	it("resets existing session when requested", async () => {
-		const kernel1 = new FakeKernel();
-		const kernel2 = new FakeKernel();
-		const starts = [kernel1, kernel2];
-		vi.spyOn(pythonKernel, "checkPythonKernelAvailability").mockResolvedValue({ ok: true });
-		const startSpy = vi.spyOn(pythonKernel.PythonKernel, "start").mockImplementation(async () => {
-			const next = starts.shift();
-			if (!next) {
-				throw new Error("No kernel available");
-			}
-			return next as unknown as pythonKernel.PythonKernel;
-		});
-
-		await executePython("print('one')", { cwd: "/tmp", sessionId: "session-3", kernelMode: "session" });
-		await executePython("print('two')", {
-			cwd: "/tmp",
-			sessionId: "session-3",
-			kernelMode: "session",
-			reset: true,
-		});
-
-		expect(startSpy).toHaveBeenCalledTimes(2);
-		expect(kernel1.shutdownCalls).toBe(1);
-		expect(kernel2.executeCalls).toBe(1);
-	});
-});

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

@@ -1,77 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { rmSync } from "node:fs";
-import { executePythonWithKernel, type PythonKernelExecutor } from "./python-executor";
-import type { KernelExecuteOptions, KernelExecuteResult } 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;
-	}
-}
-
-const cleanupPaths: string[] = [];
-
-afterEach(() => {
-	while (cleanupPaths.length > 0) {
-		const path = cleanupPaths.pop();
-		if (path) {
-			try {
-				rmSync(path, { force: true });
-			} catch {}
-		}
-	}
-});
-
-describe("executePythonWithKernel streaming", () => {
-	it("truncates large output and writes full output file", async () => {
-		const largeOutput = "a".repeat(DEFAULT_MAX_BYTES + 128);
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.(largeOutput);
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "print('hi')");
-
-		expect(result.truncated).toBe(true);
-		expect(result.fullOutputPath).toBeDefined();
-		expect(result.output.length).toBeLessThan(largeOutput.length);
-		if (result.fullOutputPath) {
-			cleanupPaths.push(result.fullOutputPath);
-		}
-	});
-
-	it("annotates timed out runs", async () => {
-		const kernel = new FakeKernel({ status: "ok", cancelled: true, timedOut: true, stdinRequested: false }, () => {});
-
-		const result = await executePythonWithKernel(kernel, "sleep", { timeout: 2000 });
-
-		expect(result.cancelled).toBe(true);
-		expect(result.exitCode).toBeUndefined();
-		expect(result.output).toContain("Command timed out after 2 seconds");
-	});
-
-	it("sanitizes ANSI and carriage returns", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: false, timedOut: false, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("\u001b[31mhello\r\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "print('hello')");
-
-		expect(result.output).toBe("hello\n");
-	});
-});

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

@@ -1,35 +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 cancellation", () => {
-	it("annotates timeouts when cancelled", async () => {
-		const kernel = new FakeKernel(
-			{ status: "ok", cancelled: true, timedOut: true, stdinRequested: false },
-			(options) => {
-				options?.onChunk?.("tick\n");
-			},
-		);
-
-		const result = await executePythonWithKernel(kernel, "sleep(10)", { timeout: 5000 });
-
-		expect(result.cancelled).toBe(true);
-		expect(result.exitCode).toBeUndefined();
-		expect(result.output).toContain("Command timed out after 5 seconds");
-	});
-});

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");
-	});
-});