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

package/src/core/settings-manager-python.test.ts

@@ -1,23 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { SettingsManager } from "./settings-manager";
-
-describe("SettingsManager python settings", () => {
-	it("defaults to both and session", () => {
-		const settings = SettingsManager.inMemory();
-
-		expect(settings.getPythonToolMode()).toBe("both");
-		expect(settings.getPythonKernelMode()).toBe("session");
-	});
-
-	it("persists python tool and kernel modes", async () => {
-		const settings = SettingsManager.inMemory();
-
-		await settings.setPythonToolMode("bash-only");
-		await settings.setPythonKernelMode("per-call");
-
-		expect(settings.getPythonToolMode()).toBe("bash-only");
-		expect(settings.getPythonKernelMode()).toBe("per-call");
-		expect(settings.serialize().python?.toolMode).toBe("bash-only");
-		expect(settings.serialize().python?.kernelMode).toBe("per-call");
-	});
-});

package/src/core/streaming-output.test.ts

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { createOutputSink } from "./streaming-output";
-
-function makeLargeOutput(size: number): string {
-	return "x".repeat(size);
-}
-
-describe("createOutputSink", () => {
-	it("spills to disk and truncates large output", async () => {
-		const largeOutput = makeLargeOutput(60_000);
-		const sink = createOutputSink(10, 70_000);
-		const writer = sink.getWriter();
-
-		await writer.write(largeOutput);
-		await writer.close();
-
-		const result = sink.dump();
-
-		expect(result.truncated).toBe(true);
-		expect(result.fullOutputPath).toBeDefined();
-		expect(result.output.length).toBeLessThan(largeOutput.length);
-
-		const fullOutput = await Bun.file(result.fullOutputPath!).text();
-		expect(fullOutput).toBe(largeOutput);
-	});
-});

package/src/core/system-prompt.python.test.ts

@@ -1,17 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { buildSystemPrompt } from "./system-prompt";
-
-describe("buildSystemPrompt", () => {
-	it("includes python tool details when enabled", async () => {
-		const prompt = await buildSystemPrompt({
-			cwd: "/tmp",
-			toolNames: ["python"],
-			contextFiles: [],
-			skills: [],
-			rules: [],
-		});
-
-		expect(prompt).toContain("python: Execute Python code via a session-backed IPython kernel");
-		expect(prompt).toContain("What python IS for");
-	});
-});

package/src/core/tools/index.test.ts

@@ -1,212 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { BUILTIN_TOOLS, createTools, HIDDEN_TOOLS, type ToolSession } from "./index";
-
-process.env.OMP_PYTHON_SKIP_CHECK = "1";
-
-function createTestSession(overrides: Partial<ToolSession> = {}): ToolSession {
-	return {
-		cwd: "/tmp/test",
-		hasUI: false,
-		getSessionFile: () => null,
-		getSessionSpawns: () => "*",
-		...overrides,
-	};
-}
-
-function createBaseSettings(overrides: Partial<NonNullable<ToolSession["settings"]>> = {}) {
-	return {
-		getImageAutoResize: () => true,
-		getLspFormatOnWrite: () => true,
-		getLspDiagnosticsOnWrite: () => true,
-		getLspDiagnosticsOnEdit: () => false,
-		getEditFuzzyMatch: () => true,
-		getGitToolEnabled: () => true,
-		getBashInterceptorEnabled: () => true,
-		getBashInterceptorSimpleLsEnabled: () => true,
-		getBashInterceptorRules: () => [],
-		...overrides,
-	};
-}
-
-describe("createTools", () => {
-	it("creates all builtin tools by default", async () => {
-		const session = createTestSession();
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		// Core tools should always be present
-		expect(names).toContain("python");
-		expect(names).not.toContain("bash");
-		expect(names).toContain("calc");
-		expect(names).toContain("read");
-		expect(names).toContain("edit");
-		expect(names).toContain("write");
-		expect(names).toContain("grep");
-		expect(names).toContain("find");
-		expect(names).toContain("ls");
-		expect(names).toContain("lsp");
-		expect(names).toContain("notebook");
-		expect(names).toContain("task");
-		expect(names).toContain("todo_write");
-		expect(names).toContain("output");
-		expect(names).toContain("web_fetch");
-		expect(names).toContain("web_search");
-	});
-
-	it("includes bash and python when python mode is both", async () => {
-		const session = createTestSession({
-			settings: createBaseSettings({
-				getPythonToolMode: () => "both",
-				getPythonKernelMode: () => "session",
-			}),
-		});
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toContain("bash");
-		expect(names).toContain("python");
-	});
-
-	it("includes bash only when python mode is bash-only", async () => {
-		const session = createTestSession({
-			settings: createBaseSettings({
-				getPythonToolMode: () => "bash-only",
-				getPythonKernelMode: () => "session",
-			}),
-		});
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toContain("bash");
-		expect(names).not.toContain("python");
-	});
-
-	it("excludes lsp tool when session disables LSP", async () => {
-		const session = createTestSession({ enableLsp: false });
-		const tools = await createTools(session, ["read", "lsp", "write"]);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toEqual(["read", "write"]);
-	});
-
-	it("excludes lsp tool when disabled", async () => {
-		const session = createTestSession({ enableLsp: false });
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).not.toContain("lsp");
-	});
-
-	it("respects requested tool subset", async () => {
-		const session = createTestSession();
-		const tools = await createTools(session, ["read", "write"]);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toEqual(["read", "write"]);
-	});
-
-	it("includes hidden tools when explicitly requested", async () => {
-		const session = createTestSession();
-		const tools = await createTools(session, ["report_finding"]);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toEqual(["report_finding"]);
-	});
-
-	it("includes complete tool when required", async () => {
-		const session = createTestSession({ requireCompleteTool: true });
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toContain("complete");
-	});
-
-	it("excludes ask tool when hasUI is false", async () => {
-		const session = createTestSession({ hasUI: false });
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).not.toContain("ask");
-	});
-
-	it("includes ask tool when hasUI is true", async () => {
-		const session = createTestSession({ hasUI: true });
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toContain("ask");
-	});
-
-	it("excludes git tool when disabled in settings", async () => {
-		const session = createTestSession({
-			settings: createBaseSettings({ getGitToolEnabled: () => false }),
-		});
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).not.toContain("git");
-	});
-
-	it("includes git tool when enabled in settings", async () => {
-		const session = createTestSession({
-			settings: createBaseSettings({ getGitToolEnabled: () => true }),
-		});
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toContain("git");
-	});
-
-	it("includes git tool when no settings provided (default enabled)", async () => {
-		const session = createTestSession({ settings: undefined });
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		expect(names).toContain("git");
-	});
-
-	it("always includes output tool when task tool is present", async () => {
-		const session = createTestSession();
-		const tools = await createTools(session);
-		const names = tools.map((t) => t.name);
-
-		// Both should be present together
-		expect(names).toContain("task");
-		expect(names).toContain("output");
-	});
-
-	it("BUILTIN_TOOLS contains all expected tools", () => {
-		const expectedTools = [
-			"ask",
-			"bash",
-			"python",
-			"calc",
-			"ssh",
-			"edit",
-			"find",
-			"git",
-			"grep",
-			"ls",
-			"lsp",
-			"notebook",
-			"output",
-			"read",
-			"task",
-			"todo_write",
-			"web_fetch",
-			"web_search",
-			"write",
-		];
-
-		for (const tool of expectedTools) {
-			expect(BUILTIN_TOOLS).toHaveProperty(tool);
-		}
-
-		// Ensure we haven't missed any
-		expect(Object.keys(BUILTIN_TOOLS).sort()).toEqual(expectedTools.sort());
-	});
-
-	it("HIDDEN_TOOLS contains review tools", () => {
-		expect(Object.keys(HIDDEN_TOOLS).sort()).toEqual(["complete", "report_finding"]);
-	});
-});

package/src/core/tools/python-execution.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it, vi } from "bun:test";
-import { mkdtempSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import * as pythonExecutor from "../python-executor";
-import type { ToolSession } from "./index";
-import { createPythonTool } from "./python";
-
-function createSession(cwd: string): ToolSession {
-	return {
-		cwd,
-		hasUI: false,
-		getSessionFile: () => "session-file",
-		getSessionSpawns: () => "*",
-		settings: {
-			getImageAutoResize: () => true,
-			getLspFormatOnWrite: () => true,
-			getLspDiagnosticsOnWrite: () => true,
-			getLspDiagnosticsOnEdit: () => false,
-			getEditFuzzyMatch: () => true,
-			getGitToolEnabled: () => true,
-			getBashInterceptorEnabled: () => true,
-			getBashInterceptorSimpleLsEnabled: () => true,
-			getBashInterceptorRules: () => [],
-			getPythonToolMode: () => "ipy-only",
-			getPythonKernelMode: () => "per-call",
-		},
-	};
-}
-
-describe("python tool execution", () => {
-	it("passes kernel options from settings and args", async () => {
-		const tempDir = mkdtempSync(join(tmpdir(), "python-tool-"));
-		const executeSpy = vi.spyOn(pythonExecutor, "executePython").mockResolvedValue({
-			output: "ok",
-			exitCode: 0,
-			cancelled: false,
-			truncated: false,
-			displayOutputs: [],
-			stdinRequested: false,
-		});
-
-		const tool = createPythonTool(createSession(tempDir));
-		const result = await tool.execute(
-			"call-id",
-			{ code: "print('hi')", timeout: 5, workdir: tempDir, reset: true },
-			undefined,
-			undefined,
-			undefined,
-		);
-
-		expect(executeSpy).toHaveBeenCalledWith(
-			"print('hi')",
-			expect.objectContaining({
-				cwd: tempDir,
-				timeout: 5000,
-				sessionId: `session:session-file:workdir:${tempDir}`,
-				kernelMode: "per-call",
-				reset: true,
-			}),
-		);
-		const text = result.content.find((item) => item.type === "text")?.text;
-		expect(text).toBe("ok");
-
-		executeSpy.mockRestore();
-		rmSync(tempDir, { recursive: true, force: true });
-	});
-});

package/src/core/tools/python-fallback.test.ts

@@ -1,72 +0,0 @@
-import { describe, expect, it, vi } from "bun:test";
-import * as pythonKernelModule from "../python-kernel";
-import type { ToolSession } from "./index";
-import { createTools } from "./index";
-
-function createTestSession(overrides: Partial<ToolSession> = {}): ToolSession {
-	return {
-		cwd: "/tmp/test",
-		hasUI: false,
-		getSessionFile: () => null,
-		getSessionSpawns: () => "*",
-		...overrides,
-	};
-}
-
-function createBaseSettings(overrides: Partial<NonNullable<ToolSession["settings"]>> = {}) {
-	return {
-		getImageAutoResize: () => true,
-		getLspFormatOnWrite: () => true,
-		getLspDiagnosticsOnWrite: () => true,
-		getLspDiagnosticsOnEdit: () => false,
-		getEditFuzzyMatch: () => true,
-		getGitToolEnabled: () => true,
-		getBashInterceptorEnabled: () => true,
-		getBashInterceptorSimpleLsEnabled: () => true,
-		getBashInterceptorRules: () => [],
-		...overrides,
-	};
-}
-
-describe("createTools python fallback", () => {
-	it("falls back to bash-only when kernel unavailable", async () => {
-		const availabilitySpy = vi
-			.spyOn(pythonKernelModule, "checkPythonKernelAvailability")
-			.mockResolvedValue({ ok: false, reason: "unavailable" });
-
-		const session = createTestSession({
-			settings: createBaseSettings({
-				getPythonToolMode: () => "ipy-only",
-				getPythonKernelMode: () => "session",
-			}),
-		});
-
-		const tools = await createTools(session, ["python"]);
-		const names = tools.map((tool) => tool.name).sort();
-
-		expect(names).toEqual(["bash"]);
-
-		availabilitySpy.mockRestore();
-	});
-
-	it("keeps bash when python mode is both but unavailable", async () => {
-		const availabilitySpy = vi
-			.spyOn(pythonKernelModule, "checkPythonKernelAvailability")
-			.mockResolvedValue({ ok: false, reason: "unavailable" });
-
-		const session = createTestSession({
-			settings: createBaseSettings({
-				getPythonToolMode: () => "both",
-				getPythonKernelMode: () => "session",
-			}),
-		});
-
-		const tools = await createTools(session);
-		const names = tools.map((tool) => tool.name);
-
-		expect(names).toContain("bash");
-		expect(names).not.toContain("python");
-
-		availabilitySpy.mockRestore();
-	});
-});

package/src/core/tools/python-renderer.test.ts

@@ -1,36 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import stripAnsi from "strip-ansi";
-import { getThemeByName } from "../../modes/interactive/theme/theme";
-import { pythonToolRenderer } from "./python";
-import { truncateTail } from "./truncate";
-
-describe("pythonToolRenderer", () => {
-	it("renders truncated output when collapsed and full output when expanded", () => {
-		const theme = getThemeByName("dark");
-		expect(theme).toBeDefined();
-		const uiTheme = theme!;
-
-		const fullOutput = ["line 1", "line 2", "line 3", "line 4"].join("\n");
-		const truncation = truncateTail(fullOutput, { maxLines: 2, maxBytes: 128 });
-
-		const result = {
-			content: [{ type: "text", text: truncation.content }],
-			details: {
-				truncation,
-				fullOutput,
-			},
-		};
-
-		const collapsed = pythonToolRenderer.renderResult(result, { expanded: false, isPartial: false }, uiTheme);
-		const collapsedLines = stripAnsi(collapsed.render(80).join("\n"));
-		expect(collapsedLines).toContain("line 4");
-		expect(collapsedLines).not.toContain("line 1");
-		expect(collapsedLines).toContain("Truncated:");
-
-		const expanded = pythonToolRenderer.renderResult(result, { expanded: true, isPartial: false }, uiTheme);
-		const expandedLines = stripAnsi(expanded.render(80).join("\n"));
-		expect(expandedLines).toContain("line 1");
-		expect(expandedLines).toContain("line 4");
-		expect(expandedLines).not.toContain("Truncated:");
-	});
-});

package/src/core/tools/python-tool-mode.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { createTools, type ToolSession } from "./index";
-
-function createSession(overrides: Partial<ToolSession> = {}): ToolSession {
-	return {
-		cwd: "/tmp/test",
-		hasUI: false,
-		getSessionFile: () => null,
-		getSessionSpawns: () => "*",
-		settings: {
-			getImageAutoResize: () => true,
-			getLspFormatOnWrite: () => true,
-			getLspDiagnosticsOnWrite: () => true,
-			getLspDiagnosticsOnEdit: () => false,
-			getEditFuzzyMatch: () => true,
-			getGitToolEnabled: () => true,
-			getBashInterceptorEnabled: () => true,
-			getBashInterceptorSimpleLsEnabled: () => true,
-			getBashInterceptorRules: () => [],
-			getPythonToolMode: () => "bash-only",
-			getPythonKernelMode: () => "session",
-		},
-		...overrides,
-	};
-}
-
-describe("createTools python fallback", () => {
-	it("falls back to bash when python is requested but disabled", async () => {
-		const previous = process.env.OMP_PYTHON_SKIP_CHECK;
-		process.env.OMP_PYTHON_SKIP_CHECK = "1";
-		const session = createSession();
-		const tools = await createTools(session, ["python"]);
-		const names = tools.map((tool) => tool.name);
-
-		expect(names).toEqual(["bash"]);
-
-		if (previous === undefined) {
-			delete process.env.OMP_PYTHON_SKIP_CHECK;
-		} else {
-			process.env.OMP_PYTHON_SKIP_CHECK = previous;
-		}
-	});
-});

package/src/core/tools/python.test.ts

@@ -1,121 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it, vi } from "bun:test";
-import * as pythonExecutor from "../python-executor";
-import { createTools, type ToolSession } from "./index";
-import { createPythonTool } from "./python";
-
-let previousSkipCheck: string | undefined;
-
-beforeAll(() => {
-	previousSkipCheck = process.env.OMP_PYTHON_SKIP_CHECK;
-	process.env.OMP_PYTHON_SKIP_CHECK = "1";
-});
-
-afterAll(() => {
-	if (previousSkipCheck === undefined) {
-		delete process.env.OMP_PYTHON_SKIP_CHECK;
-		return;
-	}
-	process.env.OMP_PYTHON_SKIP_CHECK = previousSkipCheck;
-});
-
-function createSession(overrides: Partial<ToolSession> = {}): ToolSession {
-	return {
-		cwd: "/tmp/test",
-		hasUI: false,
-		getSessionFile: () => null,
-		getSessionSpawns: () => "*",
-		...overrides,
-	};
-}
-
-function createSettings(toolMode: "ipy-only" | "bash-only" | "both") {
-	return {
-		getImageAutoResize: () => true,
-		getLspFormatOnWrite: () => true,
-		getLspDiagnosticsOnWrite: () => true,
-		getLspDiagnosticsOnEdit: () => false,
-		getEditFuzzyMatch: () => true,
-		getGitToolEnabled: () => true,
-		getBashInterceptorEnabled: () => true,
-		getBashInterceptorSimpleLsEnabled: () => true,
-		getBashInterceptorRules: () => [],
-		getPythonToolMode: () => toolMode,
-		getPythonKernelMode: () => "session" as const,
-	};
-}
-
-describe("python tool schema", () => {
-	it("exposes expected parameters", () => {
-		const tool = createPythonTool(createSession());
-		const schema = tool.parameters as {
-			type: string;
-			properties: Record<string, { type: string; description?: string }>;
-			required?: string[];
-		};
-
-		expect(schema.type).toBe("object");
-		expect(schema.properties.code.type).toBe("string");
-		expect(schema.properties.timeout.type).toBe("number");
-		expect(schema.properties.workdir.type).toBe("string");
-		expect(schema.properties.reset.type).toBe("boolean");
-		expect(schema.required).toEqual(["code"]);
-	});
-});
-
-describe("python tool docs template", () => {
-	it("renders dynamic helper docs", () => {
-		const docs = [
-			{
-				name: "read",
-				signature: "(path)",
-				docstring: "Read file contents.",
-				category: "File I/O",
-			},
-		];
-		const spy = vi.spyOn(pythonExecutor, "getPreludeDocs").mockReturnValue(docs);
-
-		const tool = createPythonTool(createSession());
-
-		expect(tool.description).toContain("### File I/O");
-		expect(tool.description).toContain("read(path)");
-		expect(tool.description).toContain("Read file contents.");
-
-		spy.mockRestore();
-	});
-
-	it("renders fallback when docs are unavailable", () => {
-		const spy = vi.spyOn(pythonExecutor, "getPreludeDocs").mockReturnValue([]);
-
-		const tool = createPythonTool(createSession());
-
-		expect(tool.description).toContain("Documentation unavailable — Python kernel failed to start");
-
-		spy.mockRestore();
-	});
-});
-
-describe("python tool exposure", () => {
-	it("includes python only in ipy-only mode", async () => {
-		const session = createSession({ settings: createSettings("ipy-only") });
-		const tools = await createTools(session);
-		const names = tools.map((tool) => tool.name);
-		expect(names).toContain("python");
-		expect(names).not.toContain("bash");
-	});
-
-	it("includes bash only in bash-only mode", async () => {
-		const session = createSession({ settings: createSettings("bash-only") });
-		const tools = await createTools(session);
-		const names = tools.map((tool) => tool.name);
-		expect(names).toContain("bash");
-		expect(names).not.toContain("python");
-	});
-
-	it("includes bash and python in both mode", async () => {
-		const session = createSession({ settings: createSettings("both") });
-		const tools = await createTools(session);
-		const names = tools.map((tool) => tool.name);
-		expect(names).toContain("bash");
-		expect(names).toContain("python");
-	});
-});