lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/components/codegraph/test/serve.test.ts

@@ -1,385 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { dirname, join, resolve } from "node:path";
-import { Readable, Writable } from "node:stream";
-import { fileURLToPath } from "node:url";
-
-import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
-import { resolveServeProcessInvocation, runCodegraphServe } from "../src/serve.ts";
-
-const componentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-
-describe("runCodegraphServe", () => {
-	it("#given CodeGraph resolves #when serving MCP #then execs codegraph serve --mcp with bridged stdio and telemetry disabled", async () => {
-		// given
-		const runCwd = componentRoot;
-		const calls: Array<{
-			readonly args: readonly string[];
-			readonly command: string;
-			readonly cwd: string;
-			readonly env: Record<string, string | undefined>;
-			readonly stdio: "pipe";
-		}> = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			cwd: runCwd,
-			env: { CUSTOM: "drop", HOME: "/tmp/home", OPENAI_API_KEY: "sk-test-secret" },
-			nodeVersion: "22.14.0",
-			homeDir: "/tmp/home",
-			resolve: () => ({ argsPrefix: ["shim.js"], command: "node", exists: true, source: "bundled" }),
-			runProcess: (
-				command: string,
-				args: readonly string[],
-				options: { readonly cwd: string; readonly env: Record<string, string | undefined>; readonly stdio: "pipe" },
-			) => {
-				calls.push({ args, command, cwd: options.cwd, env: options.env, stdio: options.stdio });
-				return Promise.resolve(7);
-			},
-			stderr: { write: () => undefined },
-		});
-
-		// then
-		expect(exitCode).toBe(7);
-		expect(calls).toEqual([
-			{
-				args: ["shim.js", "serve", "--mcp"],
-				command: "node",
-				cwd: resolve(runCwd),
-				env: {
-					CODEGRAPH_INSTALL_DIR: join("/tmp/home", ".omo", "codegraph"),
-					CODEGRAPH_NO_DOWNLOAD: "1",
-					CODEGRAPH_TELEMETRY: "0",
-					DO_NOT_TRACK: "1",
-					HOME: "/tmp/home",
-				},
-				stdio: "pipe",
-			},
-		]);
-		expect(calls[0]?.env["CUSTOM"]).toBeUndefined();
-		expect(calls[0]?.env["OPENAI_API_KEY"]).toBeUndefined();
-	});
-
-	it("#given codegraph.daemon=false #when serving MCP #then CODEGRAPH_NO_DAEMON pins daemon-off", async () => {
-		// given
-		const runCwd = componentRoot;
-		const calls: Array<{
-			readonly args: readonly string[];
-			readonly command: string;
-			readonly cwd: string;
-			readonly env: Record<string, string | undefined>;
-			readonly stdio: "pipe";
-		}> = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			config: { codegraph: { daemon: false, enabled: true }, sources: [], warnings: [] },
-			cwd: runCwd,
-			env: { CUSTOM: "drop", HOME: "/tmp/home", OPENAI_API_KEY: "sk-test-secret" },
-			nodeVersion: "22.14.0",
-			homeDir: "/tmp/home",
-			resolve: () => ({ argsPrefix: ["shim.js"], command: "node", exists: true, source: "bundled" }),
-			runProcess: (
-				command: string,
-				args: readonly string[],
-				options: { readonly cwd: string; readonly env: Record<string, string | undefined>; readonly stdio: "pipe" },
-			) => {
-				calls.push({ args, command, cwd: options.cwd, env: options.env, stdio: options.stdio });
-				return Promise.resolve(7);
-			},
-			stderr: { write: () => undefined },
-		});
-
-		// then
-		expect(exitCode).toBe(7);
-		expect(calls).toEqual([
-			{
-				args: ["shim.js", "serve", "--mcp"],
-				command: "node",
-				cwd: resolve(runCwd),
-				env: {
-					CODEGRAPH_INSTALL_DIR: join("/tmp/home", ".omo", "codegraph"),
-					CODEGRAPH_NO_DAEMON: "1",
-					CODEGRAPH_NO_DOWNLOAD: "1",
-					CODEGRAPH_TELEMETRY: "0",
-					DO_NOT_TRACK: "1",
-					HOME: "/tmp/home",
-				},
-				stdio: "pipe",
-			},
-		]);
-		expect(calls[0]?.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
-		expect(calls[0]?.env["CUSTOM"]).toBeUndefined();
-		expect(calls[0]?.env["OPENAI_API_KEY"]).toBeUndefined();
-	});
-
-	it("#given an unsupported local Node but the unsafe override is set #when serving MCP #then it still spawns codegraph", async () => {
-		// given
-		const spawned: string[] = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			env: { CODEGRAPH_ALLOW_UNSAFE_NODE: "1" },
-			nodeVersion: "26.3.0",
-			buildEnv: () => ({}),
-			resolve: () => ({ argsPrefix: ["shim.js"], command: "node", exists: true, source: "bundled" }),
-			runProcess: (command: string) => {
-				spawned.push(command);
-				return Promise.resolve(0);
-			},
-			stderr: { write: () => undefined },
-		});
-
-		// then
-		expect(exitCode).toBe(0);
-		expect(spawned).toEqual(["node"]);
-	});
-
-	it("#given an unsupported local Node but CODEGRAPH_NODE_BIN resolves a bundled shim with Node 22 #when serving MCP #then it spawns the compatible runtime", async () => {
-		// given
-		const spawned: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const nodeBin = "/opt/node22/bin/node";
-
-		// when
-		const exitCode = await runCodegraphServe({
-			env: { CODEGRAPH_NODE_BIN: nodeBin },
-			nodeVersion: "26.3.0",
-			buildEnv: () => ({}),
-			resolve: () => ({ argsPrefix: ["codegraph.js"], command: nodeBin, exists: true, source: "bundled" }),
-			runProcess: (command: string, args: readonly string[]) => {
-				spawned.push({ args, command });
-				return Promise.resolve(0);
-			},
-			stderr: { write: () => undefined },
-		});
-
-		// then
-		expect(exitCode).toBe(0);
-		expect(spawned).toEqual([{ args: ["codegraph.js", "serve", "--mcp"], command: nodeBin }]);
-	});
-
-	it("#given OMO_CODEGRAPH_BIN points at an explicit command #when local Node is unsupported #then serve trusts the configured command", async () => {
-		// given
-		const commandPath = "/opt/codegraph-node22/bin/codegraph";
-		const spawned: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			env: { OMO_CODEGRAPH_BIN: commandPath },
-			nodeVersion: "26.3.0",
-			buildEnv: () => ({}),
-			commandExists: (candidate) => candidate === commandPath,
-			resolve: () => ({ argsPrefix: [], command: commandPath, exists: true, source: "env" }),
-			runProcess: (command: string, args: readonly string[]) => {
-				spawned.push({ args, command });
-				return Promise.resolve(0);
-			},
-			stderr: { write: () => undefined },
-		});
-
-		// then
-		expect(exitCode).toBe(0);
-		expect(spawned).toEqual([{ args: ["serve", "--mcp"], command: commandPath }]);
-	});
-
-	it("#given Codex SOT install_dir has the pinned launcher and daemon is omitted #when serving MCP #then it defaults daemon-on", async () => {
-		await withProcessPlatform(process.platform, async () => {
-			// given
-			const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-install-dir-"));
-			const installDir = join(tempRoot, "custom-codegraph");
-			const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
-			const calls: Array<{
-				readonly args: readonly string[];
-				readonly command: string;
-				readonly env: Record<string, string | undefined>;
-			}> = [];
-
-			try {
-				mkdirSync(join(installDir, "bin"), { recursive: true });
-				mkdirSync(join(installDir, ".provisioned"), { recursive: true });
-				writeFileSync(binPath, "");
-				writeFileSync(
-					join(installDir, ".provisioned", `codegraph-${CODEGRAPH_PINNED_VERSION}.json`),
-					`${JSON.stringify({ binPath, version: CODEGRAPH_PINNED_VERSION })}\n`,
-				);
-
-				// when
-				const exitCode = await runCodegraphServe({
-					config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
-					env: { HOME: "/tmp/home" },
-					nodeVersion: "22.14.0",
-					homeDir: "/tmp/home",
-					resolve: (options) => {
-						const provisioned = options.provisioned?.();
-						return { argsPrefix: [], command: provisioned ?? "missing", exists: provisioned !== null && provisioned !== undefined, source: "provisioned" };
-					},
-					runProcess: (command, args, options) => {
-						calls.push({ args, command, env: options.env });
-						return Promise.resolve(0);
-					},
-					stderr: { write: () => undefined },
-				});
-
-				// then
-				expect(exitCode).toBe(0);
-				expect(calls).toEqual([
-					{
-						args: ["serve", "--mcp"],
-						command: binPath,
-						env: {
-							CODEGRAPH_INSTALL_DIR: installDir,
-							CODEGRAPH_NO_DOWNLOAD: "1",
-							CODEGRAPH_TELEMETRY: "0",
-							DO_NOT_TRACK: "1",
-							HOME: "/tmp/home",
-						},
-					},
-				]);
-			} finally {
-				rmSync(tempRoot, { recursive: true, force: true });
-			}
-		});
-	});
-
-	it("#given Codex SOT install_dir with codegraph.daemon=false #when serving MCP #then CODEGRAPH_NO_DAEMON pins daemon-off", async () => {
-		await withProcessPlatform(process.platform, async () => {
-			// given
-			const tempRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-serve-install-dir-daemon-"));
-			const installDir = join(tempRoot, "custom-codegraph");
-			const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
-			const calls: Array<{
-				readonly args: readonly string[];
-				readonly command: string;
-				readonly env: Record<string, string | undefined>;
-			}> = [];
-
-			try {
-				mkdirSync(join(installDir, "bin"), { recursive: true });
-				mkdirSync(join(installDir, ".provisioned"), { recursive: true });
-				writeFileSync(binPath, "");
-				writeFileSync(
-					join(installDir, ".provisioned", `codegraph-${CODEGRAPH_PINNED_VERSION}.json`),
-					`${JSON.stringify({ binPath, version: CODEGRAPH_PINNED_VERSION })}\n`,
-				);
-
-				// when
-				const exitCode = await runCodegraphServe({
-					config: { codegraph: { daemon: false, enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
-					env: { HOME: "/tmp/home" },
-					nodeVersion: "22.14.0",
-					homeDir: "/tmp/home",
-					resolve: (options) => {
-						const provisioned = options.provisioned?.();
-						return { argsPrefix: [], command: provisioned ?? "missing", exists: provisioned !== null && provisioned !== undefined, source: "provisioned" };
-					},
-					runProcess: (command, args, options) => {
-						calls.push({ args, command, env: options.env });
-						return Promise.resolve(0);
-					},
-					stderr: { write: () => undefined },
-				});
-
-				// then
-				expect(exitCode).toBe(0);
-				expect(calls).toEqual([
-					{
-						args: ["serve", "--mcp"],
-						command: binPath,
-						env: {
-							CODEGRAPH_INSTALL_DIR: installDir,
-							CODEGRAPH_NO_DAEMON: "1",
-							CODEGRAPH_NO_DOWNLOAD: "1",
-							CODEGRAPH_TELEMETRY: "0",
-							DO_NOT_TRACK: "1",
-							HOME: "/tmp/home",
-						},
-					},
-				]);
-				expect(calls[0]?.env["CODEGRAPH_NO_DAEMON"]).toBe("1");
-			} finally {
-				rmSync(tempRoot, { recursive: true, force: true });
-			}
-		});
-	});
-
-	it("#given project cwd is under a configured excluded root #when serving MCP #then it exposes an unavailable stub without spawning CodeGraph", async () => {
-		// given
-		const excludedRoot = mkdtempSync(join(componentRoot, ".tmp-codegraph-excluded-"));
-		const projectRoot = join(excludedRoot, "repo");
-		const stderr: string[] = [];
-		const stdout: string[] = [];
-		const calls: string[] = [];
-		mkdirSync(projectRoot, { recursive: true });
-
-		try {
-			// when
-			const exitCode = await runCodegraphServe({
-				config: { codegraph: { enabled: true, excluded_roots: [excludedRoot] }, sources: [], warnings: [] },
-				cwd: projectRoot,
-				env: { HOME: "/tmp/home" },
-				homeDir: "/tmp/home",
-				nodeVersion: "22.14.0",
-				resolve: () => ({ argsPrefix: [], command: "/tmp/codegraph", exists: true, source: "path" }),
-				runProcess: () => {
-					calls.push("spawned");
-					return Promise.resolve(0);
-				},
-				stderr: { write: (chunk) => stderr.push(chunk) },
-				stdin: Readable.from([]),
-				stdout: new Writable({
-					write: (chunk, _encoding, callback) => {
-						stdout.push(String(chunk));
-						callback();
-					},
-				}),
-			});
-
-			// then
-			expect(exitCode).toBe(0);
-			expect(calls).toEqual([]);
-			expect(stderr.join("")).toContain("CodeGraph MCP skipped: project excluded");
-		} finally {
-			rmSync(excludedRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given Windows OMO_CODEGRAPH_BIN is a Node script #when resolving serve invocation #then Node executes the script path", () => {
-		// given
-		const scriptPath = "C:\\Users\\runner\\codegraph-fake.cjs";
-
-		// when
-		const invocation = resolveServeProcessInvocation(scriptPath, ["serve", "--mcp"], "win32");
-
-		// then
-		expect(invocation).toEqual({
-			args: [scriptPath, "serve", "--mcp"],
-			command: process.execPath,
-		});
-	});
-
-	it("#given Windows CodeGraph resolves to a cmd shim #when resolving serve invocation #then cmd.exe executes the shim", () => {
-		// given
-		const shimPath = "C:\\Users\\runner\\.omo\\codegraph\\bin\\codegraph.cmd";
-
-		// when
-		const invocation = resolveServeProcessInvocation(shimPath, ["serve", "--mcp"], "win32");
-
-		// then
-		expect(invocation).toEqual({
-			args: ["/d", "/s", "/c", shimPath, "serve", "--mcp"],
-			command: "cmd.exe",
-		});
-	});
-
-});
-
-async function withProcessPlatform(platform: NodeJS.Platform, run: () => Promise<void>): Promise<void> {
-	const descriptor = Object.getOwnPropertyDescriptor(process, "platform");
-	Object.defineProperty(process, "platform", { configurable: true, enumerable: true, value: platform });
-	try {
-		await run();
-	} finally {
-		if (descriptor !== undefined) Object.defineProperty(process, "platform", descriptor);
-	}
-}

package/packages/omo-codex/plugin/components/codegraph/test/session-start-node-support.test.ts

@@ -1,206 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { runCodegraphSessionStartWorker } from "../src/hook.ts";
-
-function writeProjectDatabase(workspace: string): void {
-	mkdirSync(join(workspace, ".codegraph"), { recursive: true });
-	writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "fixture");
-}
-
-describe("CodeGraph SessionStart worker Node support", () => {
-	it("#given an unsupported local Node and a PATH CodeGraph command with auto provisioning disabled #when worker runs #then it skips without touching the workspace", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-home-"));
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { auto_provision: false, enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					resolveCommand: () => {
-						return { argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" };
-					},
-					ensureProvisioned: () => {
-						throw new Error("ensureProvisioned should not run on unsupported Node");
-					},
-					prepareWorkspace: () => {
-						throw new Error("prepareWorkspace should not run on unsupported Node");
-					},
-					runCommand: () => {
-						throw new Error("runCommand should not run on unsupported Node");
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-unsupported-node" });
-			expect(existsSync(join(workspace, ".codegraph"))).toBe(false);
-			expect(outcomes).toEqual([{ action: "skipped-unsupported-node", projectRoot: workspace }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given an unsupported local Node and a PATH CodeGraph command #when auto provisioning succeeds #then it bootstraps with the provisioned binary", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node-provision-home-"));
-		const binPath = join(homeDir, ".omo", "codegraph", "bin", "codegraph");
-		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const provisionCalls: Array<{ readonly installDir?: string; readonly lockDir: string; readonly version: "1.5.0" }> = [];
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: (options) => {
-						provisionCalls.push(options);
-						return Promise.resolve({ binPath, provisioned: true });
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: [], command: "/usr/local/bin/codegraph", exists: true, source: "path" }),
-					runCommand: (_projectRoot, command, args) => {
-						calls.push({ args, command });
-						writeProjectDatabase(workspace);
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([{ args: ["init"], command: binPath }]);
-			expect(provisionCalls).toEqual([
-				{ installDir: join(homeDir, ".omo", "codegraph"), lockDir: join(homeDir, ".omo", "codegraph", ".locks"), version: "1.5.0" },
-			]);
-			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "provisioned", timedOut: false }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given bundled CodeGraph and a stale managed install #when the worker runs #then it upgrades and uses the managed runtime", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-managed-upgrade-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-managed-upgrade-home-"));
-		const installDir = join(homeDir, ".omo", "codegraph");
-		const binPath = join(installDir, "bin", "codegraph");
-		mkdirSync(join(installDir, "bin"), { recursive: true });
-		mkdirSync(join(installDir, ".provisioned"), { recursive: true });
-		writeFileSync(binPath, "stale codegraph\n");
-		writeFileSync(
-			join(installDir, ".provisioned", "codegraph-1.4.1.json"),
-			`${JSON.stringify({ binPath, version: "1.4.1" })}\n`,
-		);
-		const provisionCalls: unknown[] = [];
-		const commandCalls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				nodeVersion: "22.14.0",
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: (options) => {
-						provisionCalls.push(options);
-						return Promise.resolve({ binPath, provisioned: true });
-					},
-					managedInstallExists: () => true,
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: ["codegraph.js"], command: "/opt/node22/bin/node", exists: true, source: "bundled" }),
-					resolveManagedBin: () => null,
-					runCommand: (_projectRoot, command, args) => {
-						commandCalls.push({ args, command });
-						writeProjectDatabase(workspace);
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(provisionCalls).toEqual([{ installDir, lockDir: join(installDir, ".locks"), version: "1.5.0" }]);
-			expect(commandCalls).toEqual([{ args: ["init"], command: binPath }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given an unsupported local Node but bundled CodeGraph resolves through CODEGRAPH_NODE_BIN #when worker runs #then it bootstraps with the compatible runtime", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-compatible-node-home-"));
-		const nodeBin = "/opt/node22/bin/node";
-		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const outcomes: unknown[] = [];
-
-		try {
-			// when
-			const result = await runCodegraphSessionStartWorker({
-				cwd: workspace,
-				env: { CODEGRAPH_NODE_BIN: nodeBin, HOME: homeDir },
-				nodeVersion: "26.3.0",
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => {
-						throw new Error("provisioning should not run when bundled CodeGraph resolved");
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: () => ({ argsPrefix: ["codegraph.js"], command: nodeBin, exists: true, source: "bundled" }),
-					runCommand: (_projectRoot, command, args) => {
-						calls.push({ args, command });
-						writeProjectDatabase(workspace);
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([{ args: ["codegraph.js", "init"], command: nodeBin }]);
-			expect(outcomes).toEqual([{ action: "initialized", exitCode: 0, projectRoot: workspace, source: "bundled", timedOut: false }]);
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-});

package/packages/omo-codex/plugin/components/codegraph/test/session-start-project.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, realpathSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { probeCodegraphProject } from "../src/session-start-project.ts";
-
-describe("CodeGraph SessionStart project probe", () => {
-	it("#given the exact project directory has a CodeGraph database #when probing #then it is initialized", () => {
-		// given
-		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-probe-exact-"));
-		try {
-			mkdirSync(join(projectRoot, ".codegraph"), { recursive: true });
-			writeFileSync(join(projectRoot, ".codegraph", "codegraph.db"), "fixture");
-
-			// when
-			const result = probeCodegraphProject(projectRoot);
-
-			// then
-			expect(result).toEqual({ kind: "initialized" });
-		} finally {
-			rmSync(projectRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given an ancestor directory has a CodeGraph database #when probing a nested project #then the ancestor covers it", () => {
-		// given
-		const ancestorRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-probe-ancestor-"));
-		const projectRoot = join(ancestorRoot, "apps", "server");
-		try {
-			mkdirSync(join(ancestorRoot, ".codegraph"), { recursive: true });
-			mkdirSync(projectRoot, { recursive: true });
-			writeFileSync(join(ancestorRoot, ".codegraph", "codegraph.db"), "fixture");
-
-			// when
-			const result = probeCodegraphProject(projectRoot);
-
-			// then
-			expect(result).toEqual({ ancestorRoot: realpathSync(ancestorRoot), kind: "nested-root" });
-		} finally {
-			rmSync(ancestorRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given neither the project nor its ancestors have a CodeGraph database #when probing #then it is definitively uninitialized", () => {
-		// given
-		const projectRoot = mkdtempSync(join(tmpdir(), "omo-codegraph-probe-missing-"));
-		try {
-			// when
-			const result = probeCodegraphProject(projectRoot);
-
-			// then
-			expect(result).toEqual({ kind: "uninitialized" });
-		} finally {
-			rmSync(projectRoot, { recursive: true, force: true });
-		}
-	});
-});