lazycodex-ai 5.0.0-beta.4 → 5.0.0-beta.42

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

@@ -1,320 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
-import { Readable } from "node:stream";
-import { fileURLToPath } from "node:url";
-
-import { runCodegraphCli } from "../src/cli.ts";
-import {
-	executeCodegraphSessionStartHook,
-	runCodegraphPostToolUseHook,
-	type WorkerSpawnInvocation,
-} from "../src/hook.ts";
-
-const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
-
-function createAllowedWorkspace(prefix: string): string {
-	return mkdtempSync(join(pluginRoot, `.tmp-${prefix}-`));
-}
-
-function expectOmoCodegraphProjectStoreGuidance(context: string): void {
-	expect(context).toContain(".omo");
-	expect(context).toContain("codegraph");
-	expect(context).toContain("projects");
-	expect(context).toContain("project-");
-}
-
-describe("CodeGraph SessionStart hook", () => {
-	it("#given hook session-start cli args #when invoked with empty JSON input #then it emits valid JSON and exits zero", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-hook-home-"));
-		try {
-			// when
-			const exitCode = await runCodegraphCli({
-				argv: ["node", "cli.js", "hook", "session-start"],
-				cwd: createAllowedWorkspace("codegraph-hook-workspace"),
-				env: { HOME: homeDir },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				ancestorProbe: () => ({ kind: "uninitialized" }),
-				spawnWorker: (invocation) => spawned.push(invocation),
-				sweepZombies: () => undefined,
-			});
-
-			// then
-			expect(exitCode).toBe(0);
-			expect(spawned).toHaveLength(1);
-			const parsed = JSON.parse(stdout.join(""));
-			expect(parsed).toEqual({
-				hookSpecificOutput: {
-					hookEventName: "SessionStart",
-					additionalContext: "LazyCodex CodeGraph bootstrap scheduled in background",
-				},
-			});
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given CodeGraph MCP reports an uninitialized project #when PostToolUse fires #then it emits OMO global-store init guidance", async () => {
-		// given
-		const output = runCodegraphPostToolUseHook(
-			{
-				cwd: "/Users/me/project",
-				tool_name: "codegraph.codegraph_status",
-				tool_response: {
-					error: [
-						"Tool execution failed: CodeGraph not initialized in /Users/me/project.",
-						"Run 'codegraph init' in that project first.",
-					].join(" "),
-				},
-			},
-			{ homeDir: "/Users/me" },
-		);
-
-		// when
-		const parsed = JSON.parse(output);
-
-		// then
-		expect(parsed.hookSpecificOutput.hookEventName).toBe("PostToolUse");
-		expect(parsed.hookSpecificOutput.additionalContext).toContain('CodeGraph is not initialized for "/Users/me/project"');
-		expectOmoCodegraphProjectStoreGuidance(parsed.hookSpecificOutput.additionalContext);
-		expect(parsed.hookSpecificOutput.additionalContext).toContain('run `codegraph init` from "/Users/me/project"');
-	});
-
-	it("#given real CodeGraph status output has no MCP path phrase #when PostToolUse fires #then it emits OMO global-store init guidance", async () => {
-		// given
-		const output = runCodegraphPostToolUseHook(
-			{
-				cwd: "/Users/me/project",
-				tool_name: "mcp__codegraph__codegraph_status",
-				tool_response: ['Project: /Users/me/project', "Not initialized", 'Run "codegraph init" to initialize'].join("\n"),
-			},
-			{ homeDir: "/Users/me" },
-		);
-
-		// when
-		const parsed = JSON.parse(output);
-
-		// then
-		expect(parsed.hookSpecificOutput.additionalContext).toContain('CodeGraph is not initialized for "/Users/me/project"');
-		expectOmoCodegraphProjectStoreGuidance(parsed.hookSpecificOutput.additionalContext);
-	});
-
-	it("#given CodeGraph is disabled by Codex SOT config #when SessionStart fires #then it skips without spawning", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-
-		// when
-		const result = await executeCodegraphSessionStartHook({
-			config: { codegraph: { enabled: false }, sources: [], warnings: [] },
-			env: {},
-			stdin: Readable.from(["{}"]),
-			stdout: { write: (chunk) => stdout.push(chunk) },
-			sweepZombies: () => undefined,
-			spawnWorker: (invocation) => spawned.push(invocation),
-		});
-
-		// then
-		expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
-		expect(spawned).toEqual([]);
-		expect(stdout.join("")).toBe("");
-	});
-
-	it("#given HOME OMO config disables Codex CodeGraph #when SessionStart fires #then it skips without spawning", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-sot-home-"));
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-sot-workspace-"));
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		try {
-			mkdirSync(join(homeDir, ".omo"), { recursive: true });
-			writeFileSync(
-				join(homeDir, ".omo", "omo.jsonc"),
-				'{ "codegraph": { "enabled": true }, "[codex]": { "codegraph": { "enabled": false } } }\n',
-			);
-
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				sweepZombies: () => undefined,
-				spawnWorker: (invocation) => spawned.push(invocation),
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
-			expect(spawned).toEqual([]);
-			expect(stdout.join("")).toBe("");
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given project Codex SOT disables global CodeGraph enablement #when SessionStart fires #then project config wins", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-project-sot-home-"));
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-project-sot-workspace-"));
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		try {
-			mkdirSync(join(homeDir, ".omo"), { recursive: true });
-			mkdirSync(join(workspace, ".omo"), { recursive: true });
-			writeFileSync(join(homeDir, ".omo", "omo.jsonc"), '{ "codegraph": { "enabled": true } }\n');
-			writeFileSync(join(workspace, ".omo", "omo.jsonc"), '{ "[codex]": { "codegraph": { "enabled": false } } }\n');
-
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				cwd: workspace,
-				env: { HOME: homeDir },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				sweepZombies: () => undefined,
-				spawnWorker: (invocation) => spawned.push(invocation),
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
-			expect(spawned).toEqual([]);
-			expect(stdout.join("")).toBe("");
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given env disables CodeGraph over SOT enablement #when SessionStart fires #then it skips without spawning", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-env-home-"));
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		try {
-			mkdirSync(join(homeDir, ".omo"), { recursive: true });
-			writeFileSync(join(homeDir, ".omo", "omo.jsonc"), '{ "codegraph": { "enabled": true } }\n');
-
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				env: { CODEX_CODEGRAPH_ENABLED: "0", HOME: homeDir },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				sweepZombies: () => undefined,
-				spawnWorker: (invocation) => spawned.push(invocation),
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
-			expect(spawned).toEqual([]);
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-		}
-	});
-
-	it("#given CodeGraph is enabled #when SessionStart fires #then it detaches a background worker immediately", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const workspace = createAllowedWorkspace("codegraph-workspace");
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-spawn-home-"));
-
-		try {
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				ancestorProbe: () => ({ kind: "uninitialized" }),
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir, KEEP: "1", OPENAI_API_KEY: "sk-test-secret" },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				spawnWorker: (invocation) => {
-					spawned.push(invocation);
-				},
-				sweepZombies: () => undefined,
-				workerCliPath: "/plugin/components/codegraph/dist/cli.js",
-			});
-
-			// then
-			expect(result).toEqual({ action: "spawned", exitCode: 0 });
-			expect(spawned).toHaveLength(1);
-			expect(spawned[0]?.args).toEqual(["/plugin/components/codegraph/dist/cli.js", "hook", "session-start-worker"]);
-			expect(spawned[0]?.command).toBe(process.execPath);
-			expect(spawned[0]?.env["HOME"]).toBe(homeDir);
-			expect(spawned[0]?.env["OMO_CODEGRAPH_SESSION_START_CWD"]).toBe(workspace);
-			expect(spawned[0]?.env["OMO_CODEGRAPH_SESSION_START_LOCK_TOKEN"]).toMatch(/^[0-9a-f-]{36}$/);
-			expect(spawned[0]?.env["OPENAI_API_KEY"]).toBeUndefined();
-			expect(spawned[0]?.env["KEEP"]).toBeUndefined();
-			expect(JSON.parse(stdout.join(""))).toEqual({
-				hookSpecificOutput: {
-					additionalContext: "LazyCodex CodeGraph bootstrap scheduled in background",
-					hookEventName: "SessionStart",
-				},
-			});
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given CodeGraph is already initialized #when SessionStart fires #then it stays silent without spawning", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const workspace = createAllowedWorkspace("codegraph-initialized-workspace");
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-initialized-home-"));
-
-		try {
-			mkdirSync(join(workspace, ".codegraph"), { recursive: true });
-			writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "fixture");
-
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				ancestorProbe: () => {
-					throw new Error("an initialized exact root must not invoke any fallback probe");
-				},
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir, KEEP: "1" },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				sweepZombies: () => undefined,
-				spawnWorker: (invocation) => spawned.push(invocation),
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-initialized", exitCode: 0 });
-			expect(spawned).toEqual([]);
-			expect(stdout.join("")).toBe("");
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given malformed hook input with CodeGraph disabled #when SessionStart fires #then it stays silent and exits zero", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-
-		// when
-		const result = await executeCodegraphSessionStartHook({
-			config: { codegraph: { enabled: false }, sources: [], warnings: [] },
-			env: {},
-			stdin: Readable.from(["{not-json"]),
-			stdout: { write: (chunk) => stdout.push(chunk) },
-			sweepZombies: () => undefined,
-			spawnWorker: (invocation) => spawned.push(invocation),
-		});
-
-		// then
-		expect(result.exitCode).toBe(0);
-		expect(spawned).toEqual([]);
-		expect(stdout.join("")).toBe("");
-	});
-
-});

package/packages/omo-codex/plugin/components/codegraph/test/mcp-bridge-fixtures.ts

@@ -1,172 +0,0 @@
-import { chmodSync, writeFileSync } from "node:fs";
-
-export const CODEGRAPH_150_DEFAULT_TOOLS: readonly Record<string, unknown>[] = [
-	{
-		name: "codegraph_explore",
-		description:
-			"PRIMARY TOOL — call FIRST for almost any question OR before an edit: how does X work, architecture, a bug, where/what is X, surveying an area, or the symbols you are about to change. Returns the verbatim source of the relevant symbols grouped by file in ONE capped call (Read-equivalent — treat the shown source as already Read; do NOT re-open those files), plus the call path among them. Query can be a natural-language question OR a bag of symbol/file names. Usually the ONLY call you need — more accurate context, in far fewer tokens and round-trips than a search/Read/Grep loop.",
-		inputSchema: {
-			type: "object",
-			properties: {
-				query: {
-					type: "string",
-					description:
-						'Symbol names, file names, or short code terms to explore (e.g., "AuthService loginUser session-manager", "GraphTraverser BFS impact traversal.ts"). For a flow question, name the symbols spanning the flow (e.g. "mutateElement renderScene"). A natural-language question works too — no prior codegraph_search needed.',
-				},
-				maxFiles: {
-					type: "number",
-					description: "Maximum number of files to include source code from (default: 12)",
-					default: 12,
-				},
-				projectPath: {
-					type: "string",
-					description:
-						"Absolute path to the project to query (or any directory inside it) — codegraph uses the nearest .codegraph/ index at or above that path. Omit to use this session's default project. Pass it to query a second codebase, or when the server root has no index of its own (e.g. a monorepo where only sub-projects are indexed, so there is no default project).",
-				},
-			},
-			required: ["query"],
-		},
-	},
-];
-
-export function writeFakeNewlineCodegraph(filePath: string): void {
-	writeFileSync(
-		filePath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"const readline = require('node:readline');",
-			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
-			"const rl = readline.createInterface({ input: process.stdin });",
-			"rl.on('line', (line) => {",
-			"  const request = JSON.parse(line);",
-			"  if (request.method === 'initialize') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { capabilities: { tools: { listChanged: false } }, protocolVersion: request.params.protocolVersion, serverInfo: { name: 'codegraph', version: '1.5.0' } } }) + '\\n');",
-			"  }",
-			"  if (request.method === 'tools/list') {",
-			`    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: ${JSON.stringify(CODEGRAPH_150_DEFAULT_TOOLS)} } }) + '\\n');`,
-			"  }",
-			"});",
-		].join("\n"),
-	);
-	chmodSync(filePath, 0o755);
-}
-
-export function writeFakeContractCodegraph(filePath: string): void {
-	writeFileSync(
-		filePath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"const readline = require('node:readline');",
-			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, `cwd=${process.cwd()}\\n`);",
-			"const rl = readline.createInterface({ input: process.stdin });",
-			"rl.on('line', (line) => {",
-			"  const request = JSON.parse(line);",
-			"  if (request.method === 'tools/list') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { tools: [",
-			"      { name: 'codegraph_search', description: 'search stays unchanged' },",
-			"      { name: 'codegraph_node', description: 'ONE SYMBOL you can name - its location, signature, verbatim source (includeCode=true) and caller/callee trail in one call', inputSchema: { type: 'object', properties: { includeCode: { type: 'boolean', description: \"Symbol mode: include the symbol's full body (default: false).\" }, symbol: { type: 'string' } } } }",
-			"    ] } }) + '\\n');",
-			"  }",
-			"  if (request.method === 'tools/call') {",
-			"    process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { content: [{ type: 'text', text: 'JsonlMCP\\nMembers (7)\\nStructural outline only. For full source, use the Read tool on this file or request a member.' }] } }) + '\\n');",
-			"  }",
-			"});",
-		].join("\n"),
-	);
-	chmodSync(filePath, 0o755);
-}
-
-export function writeFakeHeldOpenCodegraph(filePath: string): void {
-	writeFileSync(
-		filePath,
-		[
-			"#!/usr/bin/env node",
-			"const fs = require('node:fs');",
-			"const readline = require('node:readline');",
-			"fs.writeFileSync(process.env.CODEGRAPH_FAKE_LOG, String(process.pid));",
-			"const rl = readline.createInterface({ input: process.stdin });",
-			"rl.once('line', (line) => {",
-			"  const request = JSON.parse(line);",
-			"  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { ok: true } }) + '\\n');",
-			"});",
-			"setInterval(() => {}, 1000);",
-		].join("\n"),
-	);
-	chmodSync(filePath, 0o755);
-}
-
-export function writeFakeExitingCodegraph(filePath: string): void {
-	writeFileSync(
-		filePath,
-		[
-			"#!/usr/bin/env node",
-			"const readline = require('node:readline');",
-			"const rl = readline.createInterface({ input: process.stdin });",
-			"rl.once('line', (line) => {",
-			"  const request = JSON.parse(line);",
-			"  process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: request.id, result: { ok: true } }) + '\\n', () => process.exit(0));",
-			"});",
-		].join("\n"),
-	);
-	chmodSync(filePath, 0o755);
-}
-
-export function frameMcpRequest(request: {
-	readonly id: number;
-	readonly method: string;
-	readonly params: Record<string, unknown>;
-}): string {
-	const body = JSON.stringify({ jsonrpc: "2.0", ...request });
-	return `Content-Length: ${Buffer.byteLength(body)}\r\n\r\n${body}`;
-}
-
-export function parseMcpBodies(transcript: string): readonly unknown[] {
-	const bodies: unknown[] = [];
-	let cursor = 0;
-	while (cursor < transcript.length) {
-		const headerEnd = transcript.indexOf("\r\n\r\n", cursor);
-		if (headerEnd === -1) break;
-		const header = transcript.slice(cursor, headerEnd);
-		const match = /^Content-Length: (?<length>\d+)$/m.exec(header);
-		if (match?.groups?.["length"] === undefined) break;
-		const length = Number.parseInt(match.groups["length"], 10);
-		const bodyStart = headerEnd + 4;
-		const body = transcript.slice(bodyStart, bodyStart + length);
-		bodies.push(JSON.parse(body));
-		cursor = bodyStart + length;
-	}
-	return bodies;
-}
-
-export function findTool(tools: readonly unknown[], name: string): Record<string, unknown> {
-	for (const tool of tools) {
-		const record = recordValue(tool);
-		if (record["name"] === name) return record;
-	}
-	throw new Error(`Missing tool ${name}`);
-}
-
-export function arrayProperty(record: Record<string, unknown>, key: string): readonly unknown[] {
-	const value = record[key];
-	if (!Array.isArray(value)) throw new Error(`Expected ${key} to be an array`);
-	return value;
-}
-
-export function recordProperty(record: Record<string, unknown>, key: string): Record<string, unknown> {
-	return recordValue(record[key]);
-}
-
-export function stringProperty(record: Record<string, unknown>, key: string): string {
-	const value = record[key];
-	if (typeof value !== "string") throw new Error(`Expected ${key} to be a string`);
-	return value;
-}
-
-export function recordValue(value: unknown): Record<string, unknown> {
-	if (typeof value !== "object" || value === null || Array.isArray(value)) {
-		throw new Error("Expected record value");
-	}
-	return value as Record<string, unknown>;
-}

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

@@ -1,91 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-type CodegraphPackageJson = {
-	readonly files?: readonly string[];
-	readonly optionalDependencies?: Readonly<Record<string, string>>;
-};
-
-const componentRoot = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-const repoRoot = resolve(componentRoot, "../../../../..");
-
-function readCodegraphPackageJson(): CodegraphPackageJson {
-	const parsed: unknown = JSON.parse(readFileSync(resolve(componentRoot, "package.json"), "utf8"));
-	if (!isCodegraphPackageJson(parsed)) throw new TypeError("Invalid CodeGraph package metadata");
-	return parsed;
-}
-
-function isCodegraphPackageJson(value: unknown): value is CodegraphPackageJson {
-	return isRecord(value) && maybeStringArray(value["files"]) && maybeStringRecord(value["optionalDependencies"]);
-}
-
-function maybeStringArray(value: unknown): value is readonly string[] | undefined {
-	return value === undefined || (Array.isArray(value) && value.every((item) => typeof item === "string"));
-}
-
-function maybeStringRecord(value: unknown): value is Readonly<Record<string, string>> | undefined {
-	return value === undefined || (isRecord(value) && Object.values(value).every((item) => typeof item === "string"));
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-describe("CodeGraph component runtime package metadata", () => {
-	it("#given the CodeGraph component package #when validating runtime distribution metadata #then upstream CodeGraph installs optionally with shipped legal files", () => {
-		// given
-		const packageJson = readCodegraphPackageJson();
-
-		// when
-		const optionalDependencies = packageJson.optionalDependencies ?? {};
-		const files = packageJson.files ?? [];
-
-		// then
-		expect(optionalDependencies["@colbymchenry/codegraph"]).toBe("1.5.0");
-		expect(files).toContain("LICENSE");
-		expect(files).toContain("NODE-RUNTIME-LICENSES.md");
-		expect(files).toContain("NOTICE");
-		expect(existsSync(resolve(componentRoot, "LICENSE"))).toBe(true);
-		expect(existsSync(resolve(componentRoot, "NODE-RUNTIME-LICENSES.md"))).toBe(true);
-		expect(existsSync(resolve(componentRoot, "NOTICE"))).toBe(true);
-		expect(existsSync(resolve(componentRoot, "dist", "cli.d.ts"))).toBe(false);
-		expect(existsSync(resolve(componentRoot, "dist", "serve.d.ts"))).toBe(false);
-	});
-
-	it("#given marketplace payload includes only the plugin tree #when reading CodeGraph NOTICE #then it is self-contained", () => {
-		// given
-		const notice = readFileSync(resolve(componentRoot, "NOTICE"), "utf8");
-
-		expect(notice).toContain("@colbymchenry/codegraph@1.5.0");
-		expect(notice).toContain("MIT license");
-		expect(notice).toContain("Node.js v24.16.0 runtime");
-		expect(notice).toContain("NODE-RUNTIME-LICENSES.md");
-		expect(notice).not.toContain("packages/omo-codex/THIRD-PARTY-NOTICES.md");
-	});
-
-	it("#given CodeGraph platform bundles include Node #when reading runtime licenses #then Node license text ships with the component", () => {
-		// given
-		const licenseText = readFileSync(resolve(componentRoot, "NODE-RUNTIME-LICENSES.md"), "utf8");
-
-		// then
-		expect(licenseText).toContain("Node.js v24.16.0 LICENSE text");
-		expect(licenseText).toContain("Copyright Node.js contributors");
-		expect(licenseText).toContain("The externally maintained libraries used by Node.js are:");
-	});
-
-	it("#given third-party notices #when validating CodeGraph component notices #then aggregate Codex notices list CodeGraph as shipped", () => {
-		// given
-		const codexNotice = readFileSync(resolve(repoRoot, "packages/omo-codex/THIRD-PARTY-NOTICES.md"), "utf8");
-
-		// when
-		const listsCodegraphComponent = codexNotice.includes("@sisyphuslabs/codex-codegraph");
-		const listsUpstreamRuntime = codexNotice.includes("@colbymchenry/codegraph");
-
-		// then
-		expect(listsCodegraphComponent).toBe(true);
-		expect(listsUpstreamRuntime).toBe(true);
-		expect(codexNotice).not.toContain("not currently an omo-codex plugin component");
-	});
-});

package/packages/omo-codex/plugin/components/codegraph/test/provisioned-node-guard.test.ts

@@ -1,100 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-
-import { CODEGRAPH_PINNED_VERSION } from "../../../../../utils/src/codegraph/manifest.ts";
-import { runCodegraphSessionStartWorker } from "../src/hook.ts";
-import { runCodegraphServe } from "../src/serve.ts";
-
-describe("CodeGraph provisioned launcher Node guard", () => {
-	it("#given provisioned CodeGraph binary #when serve runs under unsupported local Node #then it trusts the launcher", async () => {
-		// given
-		const commandPath = "/home/test/.omo/codegraph/bin/codegraph";
-		const spawned: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-
-		// when
-		const exitCode = await runCodegraphServe({
-			env: {},
-			nodeVersion: "26.3.0",
-			buildEnv: () => ({}),
-			resolve: () => ({ argsPrefix: [], command: commandPath, exists: true, source: "provisioned" }),
-			runProcess: (command, args) => {
-				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 provisioned CodeGraph exists #when SessionStart worker runs under unsupported local Node #then it bootstraps through the launcher", async () => {
-		// given
-		const workspace = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-"));
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-home-"));
-		const installDir = mkdtempSync(join(tmpdir(), "omo-codegraph-worker-node25-install-"));
-		const binPath = join(installDir, "bin", process.platform === "win32" ? "codegraph.cmd" : "codegraph");
-		const calls: Array<{ readonly args: readonly string[]; readonly command: string }> = [];
-		const outcomes: unknown[] = [];
-
-		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 result = await runCodegraphSessionStartWorker({
-				config: { codegraph: { enabled: true, install_dir: installDir }, sources: [], trustedCodegraphInstallDir: installDir, warnings: [] },
-				nodeVersion: "26.3.0",
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				deps: {
-					ensureGitignored: () => true,
-					ensureProvisioned: () => {
-						throw new Error("provisioning should not run when install_dir binary exists");
-					},
-					prepareWorkspace: () => ({
-						dataDir: join(homeDir, ".omo/codegraph/projects/test"),
-						dataRoot: join(homeDir, ".omo/codegraph"),
-						linked: true,
-						mode: "global-linked",
-						projectLink: join(workspace, ".codegraph"),
-					}),
-					resolveCommand: (options) => {
-						const provisioned = options?.provisioned?.() ?? null;
-						return {
-							argsPrefix: [],
-							command: provisioned ?? "missing-codegraph",
-							exists: provisioned !== null,
-							source: provisioned === null ? "path" : "provisioned",
-						};
-					},
-					resolveManagedBin: () => binPath,
-					runCommand: (_projectRoot, command, args) => {
-						calls.push({ args, command });
-						mkdirSync(join(workspace, ".codegraph"), { recursive: true });
-						writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "fixture");
-						return Promise.resolve({ exitCode: 0, stdout: "", timedOut: false });
-					},
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "initialized" });
-			expect(calls).toEqual([{ args: ["init"], command: binPath }]);
-			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 });
-			rmSync(installDir, { recursive: true, force: true });
-		}
-	});
-});