oh-my-opencode 5.0.0-beta.33 → 5.0.0-beta.35

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

@@ -1,112 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { mkdirSync, mkdtempSync, rmSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { Readable } from "node:stream";
-import { fileURLToPath } from "node:url";
-
-import {
-	executeCodegraphSessionStartHook,
-	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}-`));
-}
-
-describe("CodeGraph SessionStart exclusion policy", () => {
-	it("#given project root is inside an OMO state directory #when SessionStart fires #then it skips before probing or spawning", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		let sweepCalls = 0;
-		const stateRoot = createAllowedWorkspace("codegraph-omo-state");
-		const workspace = join(stateRoot, ".omo", "ulw-research", "run", "clones", "repo");
-		mkdirSync(workspace, { recursive: true });
-
-		try {
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: "/tmp/home" },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				spawnWorker: (invocation) => spawned.push(invocation),
-				ancestorProbe: () => {
-					throw new Error("excluded projects must not probe CodeGraph ancestors");
-				},
-				sweepZombies: () => {
-					sweepCalls += 1;
-				},
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
-			expect(sweepCalls).toBe(0);
-			expect(spawned).toEqual([]);
-			expect(stdout.join("")).toBe("");
-		} finally {
-			rmSync(stateRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given project root is under a configured excluded root #when SessionStart fires #then it skips before spawning", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const excludedRoot = createAllowedWorkspace("codegraph-custom-excluded");
-		const workspace = join(excludedRoot, "repo");
-		mkdirSync(workspace, { recursive: true });
-
-		try {
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				config: { codegraph: { enabled: true, excluded_roots: [excludedRoot] }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: "/tmp/home" },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				ancestorProbe: () => ({ kind: "uninitialized" }),
-				spawnWorker: (invocation) => spawned.push(invocation),
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
-			expect(spawned).toEqual([]);
-			expect(stdout.join("")).toBe("");
-		} finally {
-			rmSync(excludedRoot, { recursive: true, force: true });
-		}
-	});
-
-	it("#given project root is under /tmp #when SessionStart fires on POSIX #then it skips before spawning", async () => {
-		if (process.platform === "win32") return;
-
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const workspace = mkdtempSync(join("/tmp", "omo-codegraph-excluded-"));
-
-		try {
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: "/tmp/home" },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				ancestorProbe: () => ({ kind: "uninitialized" }),
-				spawnWorker: (invocation) => spawned.push(invocation),
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-excluded", exitCode: 0 });
-			expect(spawned).toEqual([]);
-			expect(stdout.join("")).toBe("");
-		} finally {
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-});

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

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { readFileSync } from "node:fs";
-import { resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-
-const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
-const pluginConfigPath = resolve(pluginRoot, ".codex-plugin/plugin.json");
-
-describe("CodeGraph hook registration", () => {
-	it("#given plugin hook config #when inspected #then CodeGraph is registered after bootstrap SessionStart", () => {
-		// given
-		const pluginConfig: unknown = JSON.parse(readFileSync(pluginConfigPath, "utf8"));
-
-		// when
-		const hookPaths =
-			typeof pluginConfig === "object" && pluginConfig !== null && "hooks" in pluginConfig && Array.isArray(pluginConfig.hooks)
-				? pluginConfig.hooks.filter((hookPath): hookPath is string => typeof hookPath === "string")
-				: [];
-
-		// then
-		expect(hookPaths).toContain("./hooks/session-start-checking-codegraph-bootstrap.json");
-		expect(hookPaths.indexOf("./hooks/session-start-checking-bootstrap-provisioning.json")).toBeLessThan(
-			hookPaths.indexOf("./hooks/session-start-checking-codegraph-bootstrap.json"),
-		);
-	});
-});

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

@@ -1,160 +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 {
-	executeCodegraphSessionStartHook,
-	type CodegraphSessionStartOutcome,
-	type WorkerSpawnInvocation,
-} from "../src/hook.ts";
-import { recordSessionStartFailure } from "../src/session-start-cooldown.ts";
-
-const pluginRoot = resolve(fileURLToPath(new URL("../../..", import.meta.url)));
-
-function createAllowedWorkspace(prefix: string): string {
-	return mkdtempSync(join(pluginRoot, `.tmp-${prefix}-`));
-}
-
-describe("CodeGraph SessionStart spawn guards", () => {
-	it("#given an inconclusive probe timeout #when SessionStart runs #then timeout is not treated as uninitialized", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-timeout-home-"));
-		const workspace = createAllowedWorkspace("codegraph-timeout-workspace");
-		const spawned: WorkerSpawnInvocation[] = [];
-		try {
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				ancestorProbe: () => ({ kind: "inconclusive", reason: "status timed out" }),
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				spawnWorker: (invocation) => spawned.push(invocation),
-				stdin: Readable.from(["{}"]),
-				sweepZombies: () => undefined,
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-inconclusive", exitCode: 0 });
-			expect(spawned).toEqual([]);
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given one hook already owns the project lock #when a second SessionStart runs #then it records skipped-locked without spawning", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-dedup-home-"));
-		const workspace = createAllowedWorkspace("codegraph-dedup-workspace");
-		const outcomes: CodegraphSessionStartOutcome[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const options = {
-			ancestorProbe: () => ({ kind: "uninitialized" } as const),
-			config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-			cwd: workspace,
-			env: { HOME: homeDir },
-			logOutcome: (outcome: CodegraphSessionStartOutcome) => outcomes.push(outcome),
-			spawnWorker: (invocation: WorkerSpawnInvocation) => {
-				spawned.push(invocation);
-			},
-			stdin: Readable.from(["{}"]),
-			sweepZombies: () => undefined,
-		};
-		try {
-			await executeCodegraphSessionStartHook(options);
-
-			// when
-			const second = await executeCodegraphSessionStartHook({ ...options, stdin: Readable.from(["{}"]) });
-
-			// then
-			expect(second).toEqual({ action: "skipped-locked", exitCode: 0 });
-			expect(spawned).toHaveLength(1);
-			expect(outcomes).toContainEqual({ action: "skipped-locked", projectRoot: workspace });
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given a failed worker cooldown #when SessionStart retries before and after expiry #then only the expired retry spawns", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-cooldown-hook-home-"));
-		const workspace = createAllowedWorkspace("codegraph-cooldown-hook-workspace");
-		const outcomes: CodegraphSessionStartOutcome[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		try {
-			recordSessionStartFailure({
-				action: "failed",
-				baseCooldownMs: 60_000,
-				homeDir,
-				nowMs: 1_000,
-				projectRoot: workspace,
-			});
-			const baseOptions = {
-				ancestorProbe: () => ({ kind: "uninitialized" } as const),
-				config: { codegraph: { enabled: true, session_start_cooldown_ms: 60_000 }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome: CodegraphSessionStartOutcome) => outcomes.push(outcome),
-				spawnWorker: (invocation: WorkerSpawnInvocation) => {
-					spawned.push(invocation);
-				},
-				sweepZombies: () => undefined,
-			};
-
-			// when
-			const suppressed = await executeCodegraphSessionStartHook({ ...baseOptions, nowMs: 60_999, stdin: Readable.from(["{}"]) });
-			const expired = await executeCodegraphSessionStartHook({ ...baseOptions, nowMs: 61_000, stdin: Readable.from(["{}"]) });
-
-			// then
-			expect(suppressed).toEqual({ action: "skipped-cooldown", exitCode: 0 });
-			expect(expired).toEqual({ action: "spawned", exitCode: 0 });
-			expect(spawned).toHaveLength(1);
-			expect(outcomes).toContainEqual({
-				action: "skipped-cooldown",
-				cooldownUntil: 61_000,
-				failureCount: 1,
-				projectRoot: workspace,
-			});
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(workspace, { recursive: true, force: true });
-		}
-	});
-
-	it("#given an ancestor has a CodeGraph database #when SessionStart runs in a nested project #then it records skipped-nested-root", async () => {
-		// given
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-nested-home-"));
-		const ancestorRoot = createAllowedWorkspace("codegraph-nested-ancestor");
-		const workspace = join(ancestorRoot, "apps", "server");
-		const outcomes: CodegraphSessionStartOutcome[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		try {
-			mkdirSync(join(ancestorRoot, ".codegraph"), { recursive: true });
-			mkdirSync(workspace, { recursive: true });
-			writeFileSync(join(ancestorRoot, ".codegraph", "codegraph.db"), "fixture");
-
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				logOutcome: (outcome) => outcomes.push(outcome),
-				spawnWorker: (invocation) => spawned.push(invocation),
-				stdin: Readable.from(["{}"]),
-				sweepZombies: () => undefined,
-			});
-
-			// then
-			expect(result).toEqual({ action: "skipped-nested-root", exitCode: 0 });
-			expect(spawned).toEqual([]);
-			expect(outcomes).toContainEqual({ action: "skipped-nested-root", ancestorRoot, projectRoot: workspace });
-		} finally {
-			rmSync(homeDir, { recursive: true, force: true });
-			rmSync(ancestorRoot, { recursive: true, force: true });
-		}
-	});
-});

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

@@ -1,50 +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 { executeCodegraphSessionStartHook, 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}-`));
-}
-
-describe("CodeGraph SessionStart hook with a migrated 1.0.1 project store under CodeGraph 1.5.0", () => {
-	it("#given the migrated store has an exact database #when SessionStart runs #then it never invokes the CodeGraph CLI", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-		const homeDir = mkdtempSync(join(tmpdir(), "omo-codegraph-upgrade-home-"));
-		const workspace = createAllowedWorkspace("codegraph-upgrade-workspace");
-		try {
-			mkdirSync(join(workspace, ".codegraph"), { recursive: true });
-			writeFileSync(join(workspace, ".codegraph", "codegraph.db"), "migrated-store");
-
-			// when
-			const result = await executeCodegraphSessionStartHook({
-				ancestorProbe: () => {
-					throw new Error("the exact database check must be the complete fast path");
-				},
-				config: { codegraph: { enabled: true }, sources: [], warnings: [] },
-				cwd: workspace,
-				env: { HOME: homeDir },
-				stdin: Readable.from(["{}"]),
-				stdout: { write: (chunk) => stdout.push(chunk) },
-				spawnWorker: (invocation) => spawned.push(invocation),
-				sweepZombies: () => undefined,
-			});
-
-			// 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 });
-		}
-	});
-});

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

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { Readable } from "node:stream";
-
-import { executeCodegraphSessionStartHook, type WorkerSpawnInvocation } from "../src/hook.ts";
-
-describe("CodeGraph SessionStart zombie sweep", () => {
-	it("#given the zombie sweep fails #when SessionStart fires #then the hook still exits zero", async () => {
-		// given
-		const stdout: string[] = [];
-		const spawned: WorkerSpawnInvocation[] = [];
-
-		// when
-		const result = await executeCodegraphSessionStartHook({
-			config: { codegraph: { enabled: false }, sources: [], warnings: [] },
-			env: { HOME: "/tmp/home" },
-			stdin: Readable.from(["{}"]),
-			stdout: { write: (chunk) => stdout.push(chunk) },
-			spawnWorker: (invocation) => spawned.push(invocation),
-			sweepZombies: () => {
-				throw new Error("ps unavailable");
-			},
-		});
-
-		// then
-		expect(result).toEqual({ action: "skipped-disabled", exitCode: 0 });
-		expect(spawned).toEqual([]);
-		expect(stdout.join("")).toBe("");
-	});
-});