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

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

@@ -1,102 +0,0 @@
-import { afterEach, describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join, resolve } from "node:path";
-import { discoverPythonModules, loadPythonModules, type PythonModuleExecutor } from "./python-modules";
-
-const fixturesDir = resolve(__dirname, "../../test/fixtures/python-modules");
-
-const readFixture = (name: string): string => readFileSync(join(fixturesDir, name), "utf-8");
-
-const writeModule = (dir: string, name: string, tag: string) => {
-	mkdirSync(dir, { recursive: true });
-	const base = readFixture(name);
-	writeFileSync(join(dir, name), `${base}\n# ${tag}`);
-};
-
-const createTempRoot = () => mkdtempSync(join(tmpdir(), "omp-python-modules-"));
-
-describe("python modules", () => {
-	let tempRoot: string | null = null;
-
-	afterEach(() => {
-		if (tempRoot) {
-			rmSync(tempRoot, { recursive: true, force: true });
-		}
-		tempRoot = null;
-	});
-
-	it("discovers modules with project override and sorted order", async () => {
-		tempRoot = createTempRoot();
-		const homeDir = join(tempRoot, "home");
-		const cwd = join(tempRoot, "project");
-
-		writeModule(join(homeDir, ".omp", "agent", "modules"), "alpha.py", "user-omp");
-		writeModule(join(homeDir, ".pi", "agent", "modules"), "beta.py", "user-pi");
-		writeModule(join(homeDir, ".pi", "agent", "modules"), "delta.py", "user-pi");
-
-		writeModule(join(cwd, ".omp", "modules"), "alpha.py", "project-omp");
-		writeModule(join(cwd, ".omp", "modules"), "beta.py", "project-omp");
-		writeModule(join(cwd, ".pi", "modules"), "gamma.py", "project-pi");
-
-		const modules = await discoverPythonModules({ cwd, homeDir });
-		const names = modules.map((module) => basename(module.path));
-		expect(names).toEqual(["alpha.py", "beta.py", "delta.py", "gamma.py"]);
-		expect(modules.map((module) => ({ name: basename(module.path), source: module.source }))).toEqual([
-			{ name: "alpha.py", source: "project" },
-			{ name: "beta.py", source: "project" },
-			{ name: "delta.py", source: "user" },
-			{ name: "gamma.py", source: "project" },
-		]);
-		expect(modules.find((module) => module.path.endsWith("alpha.py"))?.content).toContain("project-omp");
-		expect(modules.find((module) => module.path.endsWith("delta.py"))?.content).toContain("user-pi");
-	});
-
-	it("loads modules in sorted order with silent execution", async () => {
-		tempRoot = createTempRoot();
-		const homeDir = join(tempRoot, "home");
-		const cwd = join(tempRoot, "project");
-
-		writeModule(join(homeDir, ".omp", "agent", "modules"), "beta.py", "user-omp");
-		writeModule(join(homeDir, ".omp", "agent", "modules"), "alpha.py", "user-omp");
-
-		const calls: Array<{ name: string; options?: { silent?: boolean; storeHistory?: boolean } }> = [];
-		const executor: PythonModuleExecutor = {
-			execute: async (code: string, options?: { silent?: boolean; storeHistory?: boolean }) => {
-				const name = code.includes("def alpha") ? "alpha" : "beta";
-				calls.push({ name, options });
-				return { status: "ok", cancelled: false };
-			},
-		};
-
-		await loadPythonModules(executor, { cwd, homeDir });
-		expect(calls.map((call) => call.name)).toEqual(["alpha", "beta"]);
-		for (const call of calls) {
-			expect(call.options).toEqual({ silent: true, storeHistory: false });
-		}
-	});
-
-	it("fails fast when a module fails to execute", async () => {
-		tempRoot = createTempRoot();
-		const homeDir = join(tempRoot, "home");
-		const cwd = join(tempRoot, "project");
-
-		writeModule(join(homeDir, ".omp", "agent", "modules"), "alpha.py", "user-omp");
-		writeModule(join(cwd, ".omp", "modules"), "beta.py", "project-omp");
-
-		const executor: PythonModuleExecutor = {
-			execute: async (code: string) => {
-				if (code.includes("def beta")) {
-					return {
-						status: "error",
-						cancelled: false,
-						error: { name: "Error", value: "boom", traceback: [] },
-					};
-				}
-				return { status: "ok", cancelled: false };
-			},
-		};
-
-		await expect(loadPythonModules(executor, { cwd, homeDir })).rejects.toThrow("Failed to load Python module");
-	});
-});

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

@@ -1,140 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync } from "node:fs";
-import { join } from "node:path";
-import { resetPreludeDocsCache, warmPythonEnvironment } from "./python-executor";
-import { createPythonTool, getPythonToolDescription } from "./tools/python";
-
-const resolvePythonPath = (): string | null => {
-	const venvPath = process.env.VIRTUAL_ENV;
-	const candidates = [venvPath, join(process.cwd(), ".venv"), join(process.cwd(), "venv")].filter(Boolean) as string[];
-	for (const candidate of candidates) {
-		const binDir = process.platform === "win32" ? "Scripts" : "bin";
-		const exeName = process.platform === "win32" ? "python.exe" : "python";
-		const pythonCandidate = join(candidate, binDir, exeName);
-		if (existsSync(pythonCandidate)) {
-			return pythonCandidate;
-		}
-	}
-	return Bun.which("python") ?? Bun.which("python3");
-};
-
-const pythonPath = resolvePythonPath();
-const hasKernelDeps = (() => {
-	if (!pythonPath) return false;
-	const result = Bun.spawnSync(
-		[
-			pythonPath,
-			"-c",
-			"import importlib.util,sys;sys.exit(0 if importlib.util.find_spec('kernel_gateway') and importlib.util.find_spec('ipykernel') else 1)",
-		],
-		{ stdin: "ignore", stdout: "pipe", stderr: "pipe" },
-	);
-	return result.exitCode === 0;
-})();
-
-const shouldRun = Boolean(pythonPath) && hasKernelDeps;
-
-describe.skipIf(!shouldRun)("PYTHON_PRELUDE integration", () => {
-	it("exposes prelude helpers via python tool", async () => {
-		const helpers = [
-			"pwd",
-			"cd",
-			"env",
-			"read",
-			"write",
-			"append",
-			"mkdir",
-			"rm",
-			"mv",
-			"cp",
-			"ls",
-			"cat",
-			"touch",
-			"find",
-			"grep",
-			"rgrep",
-			"head",
-			"tail",
-			"replace",
-			"sed",
-			"rsed",
-			"wc",
-			"sort_lines",
-			"uniq",
-			"cols",
-			"tree",
-			"stat",
-			"diff",
-			"glob_files",
-			"batch",
-			"lines",
-			"delete_lines",
-			"delete_matching",
-			"insert_at",
-			"git_status",
-			"git_diff",
-			"git_log",
-			"git_show",
-			"git_file_at",
-			"git_branch",
-			"git_has_changes",
-			"run",
-			"sh",
-		];
-
-		const session = {
-			cwd: process.cwd(),
-			hasUI: false,
-			getSessionFile: () => null,
-			getSessionSpawns: () => null,
-			settings: {
-				getImageAutoResize: () => true,
-				getLspFormatOnWrite: () => false,
-				getLspDiagnosticsOnWrite: () => false,
-				getLspDiagnosticsOnEdit: () => false,
-				getEditFuzzyMatch: () => true,
-				getGitToolEnabled: () => true,
-				getBashInterceptorEnabled: () => true,
-				getBashInterceptorSimpleLsEnabled: () => true,
-				getBashInterceptorRules: () => [],
-				getPythonToolMode: () => "ipy-only" as const,
-				getPythonKernelMode: () => "per-call" as const,
-			},
-		};
-
-		const tool = createPythonTool(session);
-		const code = `
-	helpers = ${JSON.stringify(helpers)}
-	missing = [name for name in helpers if name not in globals() or not callable(globals()[name])]
-	docs = __omp_prelude_docs__()
-	doc_names = [d.get("name") for d in docs]
-	doc_categories = [d.get("category") for d in docs]
-	print("HELPERS_OK=" + ("1" if not missing else "0"))
-	print("DOCS_OK=" + ("1" if "pwd" in doc_names and "Navigation" in doc_categories else "0"))
-	if missing:
-	    print("MISSING=" + ",".join(missing))
-	`;
-
-		const result = await tool.execute("tool-call-1", { code });
-		const output = result.content.find((item) => item.type === "text")?.text ?? "";
-		expect(output).toContain("HELPERS_OK=1");
-		expect(output).toContain("DOCS_OK=1");
-	});
-
-	it("exposes prelude docs via warmup", async () => {
-		resetPreludeDocsCache();
-		const result = await warmPythonEnvironment(process.cwd(), undefined, false);
-		expect(result.ok).toBe(true);
-		const names = result.docs.map((doc) => doc.name);
-		expect(names).toContain("pwd");
-	});
-
-	it("renders prelude docs in python tool description", async () => {
-		resetPreludeDocsCache();
-		const result = await warmPythonEnvironment(process.cwd(), undefined, false);
-		expect(result.ok).toBe(true);
-		const description = getPythonToolDescription();
-		expect(description).toContain("pwd");
-		expect(description).not.toContain("Documentation unavailable");
-	});
-});

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