lazycodex-ai 5.0.0-beta.9 → 5.0.0

package/packages/omo-codex/plugin/components/codegraph/src/session-start-outcome.ts

@@ -1,15 +0,0 @@
-import { appendFileSync, mkdirSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-import { codegraphDataRoot } from "../../../../../utils/src/codegraph/paths.ts";
-import type { CodegraphSessionStartOutcome } from "./hook-types.js";
-
-export function appendSessionStartOutcome(
-	homeDir: string,
-	outcome: CodegraphSessionStartOutcome,
-	nowMs: number = Date.now(),
-): void {
-	const path = join(codegraphDataRoot(homeDir), "session-start.jsonl");
-	mkdirSync(dirname(path), { recursive: true });
-	appendFileSync(path, `${JSON.stringify({ ...outcome, timestamp: new Date(nowMs).toISOString() })}\n`);
-}

package/packages/omo-codex/plugin/components/codegraph/src/session-start-paths.ts

@@ -1,32 +0,0 @@
-import { basename, dirname, join } from "node:path";
-
-import {
-	canonicalizeCodegraphPath,
-	resolveCodegraphWorkspacePaths,
-} from "../../../../../utils/src/codegraph/paths.ts";
-
-export interface SessionStartStatePaths {
-	readonly canonicalProjectRoot: string;
-	readonly cooldownPath: string;
-	readonly lockPath: string;
-	readonly outcomePath: string;
-	readonly stateDirectory: string;
-}
-
-export function resolveSessionStartStatePaths(homeDir: string, projectRoot: string): SessionStartStatePaths {
-	const canonicalProjectRoot = canonicalizeCodegraphPath(projectRoot);
-	const workspacePaths = resolveCodegraphWorkspacePaths(canonicalProjectRoot, { homeDir });
-	const projectKey = basename(workspacePaths.dataDir);
-	const stateDirectory = join(workspacePaths.dataRoot, "session-start");
-	return {
-		canonicalProjectRoot,
-		cooldownPath: join(stateDirectory, "cooldowns", `${projectKey}.json`),
-		lockPath: join(stateDirectory, "locks", `${projectKey}.lock`),
-		outcomePath: join(workspacePaths.dataRoot, "session-start.jsonl"),
-		stateDirectory,
-	};
-}
-
-export function stateParent(path: string): string {
-	return dirname(path);
-}

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

@@ -1,109 +0,0 @@
-import { realpathSync, statSync } from "node:fs";
-import { dirname, join } from "node:path";
-
-export type CodegraphProjectState =
-	| { readonly kind: "inconclusive"; readonly reason: string }
-	| { readonly kind: "initialized" }
-	| { readonly ancestorRoot: string; readonly kind: "nested-root" }
-	| { readonly kind: "uninitialized" };
-
-export type CodegraphAncestorState = Exclude<CodegraphProjectState, { readonly kind: "initialized" }>;
-export type CodegraphExactProjectState = Extract<
-	CodegraphProjectState,
-	{ readonly kind: "inconclusive" | "initialized" | "uninitialized" }
->;
-
-type DatabaseState =
-	| { readonly kind: "inconclusive"; readonly reason: string }
-	| { readonly kind: "missing" }
-	| { readonly kind: "present" };
-
-export interface CodegraphProjectProbeOptions {
-	readonly probeDatabase?: (directory: string) => DatabaseState;
-}
-
-export function probeCodegraphProject(
-	projectRoot: string,
-	options: CodegraphProjectProbeOptions = {},
-): CodegraphProjectState {
-	const resolved = resolveProjectRoot(projectRoot);
-	if (resolved.kind === "inconclusive") return resolved;
-
-	const probeDatabase = options.probeDatabase ?? probeDatabaseAt;
-	const exact = probeResolvedExactProject(resolved.projectRoot, probeDatabase);
-	if (exact.kind !== "uninitialized") return exact;
-	return probeResolvedAncestors(resolved.projectRoot, probeDatabase);
-}
-
-export function probeExactCodegraphProject(
-	projectRoot: string,
-	options: CodegraphProjectProbeOptions = {},
-): CodegraphExactProjectState {
-	const resolved = resolveProjectRoot(projectRoot);
-	if (resolved.kind === "inconclusive") return resolved;
-	return probeResolvedExactProject(resolved.projectRoot, options.probeDatabase ?? probeDatabaseAt);
-}
-
-export function probeCodegraphAncestors(
-	projectRoot: string,
-	options: CodegraphProjectProbeOptions = {},
-): CodegraphAncestorState {
-	const resolved = resolveProjectRoot(projectRoot);
-	if (resolved.kind === "inconclusive") return resolved;
-	return probeResolvedAncestors(resolved.projectRoot, options.probeDatabase ?? probeDatabaseAt);
-}
-
-function probeResolvedExactProject(
-	projectRoot: string,
-	probeDatabase: (directory: string) => DatabaseState,
-): CodegraphExactProjectState {
-	const exact = probeDatabase(projectRoot);
-	if (exact.kind === "present") return { kind: "initialized" };
-	if (exact.kind === "inconclusive") return exact;
-	return { kind: "uninitialized" };
-}
-
-function probeResolvedAncestors(
-	projectRoot: string,
-	probeDatabase: (directory: string) => DatabaseState,
-): CodegraphAncestorState {
-	let ancestorRoot = dirname(projectRoot);
-	while (ancestorRoot !== projectRoot) {
-		const database = probeDatabase(ancestorRoot);
-		if (database.kind === "present") return { ancestorRoot, kind: "nested-root" };
-		if (database.kind === "inconclusive") return database;
-		const parent = dirname(ancestorRoot);
-		if (parent === ancestorRoot) break;
-		ancestorRoot = parent;
-	}
-	return { kind: "uninitialized" };
-}
-
-function resolveProjectRoot(projectRoot: string):
-	| { readonly kind: "inconclusive"; readonly reason: string }
-	| { readonly kind: "resolved"; readonly projectRoot: string } {
-	try {
-		return { kind: "resolved", projectRoot: realpathSync(projectRoot) };
-	} catch (error) {
-		if (error instanceof Error) return { kind: "inconclusive", reason: error.message };
-		throw error;
-	}
-}
-
-function probeDatabaseAt(directory: string): DatabaseState {
-	try {
-		statSync(join(directory, ".codegraph", "codegraph.db"));
-		return { kind: "present" };
-	} catch (error) {
-		if (!(error instanceof Error)) throw error;
-		const code = errorCode(error);
-		if (code === "ENOENT" || code === "ENOTDIR") return { kind: "missing" };
-		return { kind: "inconclusive", reason: error.message };
-	}
-}
-
-function errorCode(error: unknown): string | undefined {
-	if (typeof error !== "object" || error === null) return undefined;
-	const code = Reflect.get(error, "code");
-	return typeof code === "string" ? code : undefined;
-}

package/packages/omo-codex/plugin/components/codegraph/src/session-start-worker-result.ts

@@ -1,148 +0,0 @@
-import { env as processEnv, stderr as processStderr } from "node:process";
-
-import type { CodegraphCommandResolution } from "../../../../../utils/src/codegraph/resolve.ts";
-import type { CodegraphSessionStartOutcome, WorkerAction } from "./hook-types.js";
-import {
-	clearSessionStartCooldown,
-	recordSessionStartFailure,
-	type SessionStartFailureAction,
-} from "./session-start-cooldown.js";
-import type { CodegraphProjectState } from "./session-start-project.js";
-
-export type WorkerResultContext = {
-	readonly baseCooldownMs: number;
-	readonly homeDir: string;
-	readonly logOutcome: (outcome: CodegraphSessionStartOutcome) => void;
-	readonly nowMs: () => number;
-	readonly projectRoot: string;
-};
-
-export type WorkerRunResult = {
-	readonly action: WorkerAction;
-	readonly releaseLock: boolean;
-};
-
-export function finishWorkerProjectState(
-	state: CodegraphProjectState,
-	context: WorkerResultContext,
-): WorkerRunResult | null {
-	switch (state.kind) {
-		case "inconclusive":
-			return finishWorkerFailure("skipped-probe-error", "skipped-probe-error", {
-				error: state.reason,
-				projectRoot: context.projectRoot,
-			}, context);
-		case "initialized":
-			return finishWorkerSuccess("skipped-initialized", { projectRoot: context.projectRoot }, context);
-		case "nested-root":
-			return finishWorkerSuccess("skipped-nested-root", {
-				ancestorRoot: state.ancestorRoot,
-				projectRoot: context.projectRoot,
-			}, context);
-		case "uninitialized":
-			return null;
-	}
-}
-
-export function finishWorkerInitialization(
-	state: CodegraphProjectState,
-	detail: {
-		readonly exitCode: number;
-		readonly source: CodegraphCommandResolution["source"];
-	},
-	context: WorkerResultContext,
-): WorkerRunResult {
-	switch (state.kind) {
-		case "inconclusive":
-			return finishWorkerFailure("skipped-probe-error", "skipped-probe-error", {
-				error: state.reason,
-				...detail,
-				projectRoot: context.projectRoot,
-				timedOut: false,
-			}, context);
-		case "initialized":
-			return finishWorkerSuccess("initialized", {
-				...detail,
-				projectRoot: context.projectRoot,
-				timedOut: false,
-			}, context);
-		case "nested-root":
-			return finishWorkerFailure("failed", "failed", {
-				...detail,
-				error: `codegraph init resolved to ancestor database at ${state.ancestorRoot}`,
-				projectRoot: context.projectRoot,
-				timedOut: false,
-			}, context);
-		case "uninitialized":
-			return finishWorkerFailure("failed", "failed", {
-				...detail,
-				error: "codegraph init completed without creating an exact project database",
-				projectRoot: context.projectRoot,
-				timedOut: false,
-			}, context);
-	}
-}
-
-export function finishWorkerFailure(
-	action: WorkerAction,
-	failureAction: SessionStartFailureAction,
-	detail: Omit<CodegraphSessionStartOutcome, "action">,
-	context: WorkerResultContext,
-): WorkerRunResult {
-	let releaseLock = true;
-	try {
-		recordSessionStartFailure({
-			action: failureAction,
-			baseCooldownMs: context.baseCooldownMs,
-			homeDir: context.homeDir,
-			nowMs: context.nowMs(),
-			projectRoot: context.projectRoot,
-		});
-	} catch (error) {
-		if (error instanceof Error) releaseLock = false;
-		else throw error;
-	}
-	safeLogWorkerOutcome(context.logOutcome, { ...detail, action });
-	return { action, releaseLock };
-}
-
-export function finishWorkerSuccess(
-	action: WorkerAction,
-	detail: Omit<CodegraphSessionStartOutcome, "action">,
-	context: WorkerResultContext,
-): WorkerRunResult {
-	try {
-		clearSessionStartCooldown({ homeDir: context.homeDir, projectRoot: context.projectRoot });
-	} catch (error) {
-		if (error instanceof Error) writeDebugLog(`failed to clear SessionStart cooldown: ${error.message}`);
-		else throw error;
-	}
-	safeLogWorkerOutcome(context.logOutcome, { ...detail, action });
-	return { action, releaseLock: true };
-}
-
-export function finishWorkerNeutral(
-	action: WorkerAction,
-	detail: Omit<CodegraphSessionStartOutcome, "action">,
-	context: WorkerResultContext,
-): WorkerRunResult {
-	safeLogWorkerOutcome(context.logOutcome, { ...detail, action });
-	return { action, releaseLock: true };
-}
-
-export function safeLogWorkerOutcome(
-	logOutcome: (outcome: CodegraphSessionStartOutcome) => void,
-	outcome: CodegraphSessionStartOutcome,
-): void {
-	try {
-		logOutcome(outcome);
-	} catch (error) {
-		if (error instanceof Error) processStderr.write(`[codegraph-session-start] failed to write outcome: ${error.message}\n`);
-		else throw error;
-	}
-}
-
-function writeDebugLog(message: string): void {
-	if (processEnv["OMO_CODEGRAPH_DEBUG"] !== "1") return;
-	processStderr.write(`[codegraph-session-start] ${message}\n`);
-}

package/packages/omo-codex/plugin/components/codegraph/src/session-start-worker.ts

@@ -1,175 +0,0 @@
-import { homedir } from "node:os";
-import { cwd as processCwd, env as processEnv } from "node:process";
-
-import { getCodexOmoConfig } from "../../../shared/src/config-loader.ts";
-import { hasCodegraphManagedInstall, resolvePinnedCodegraphBin } from "../../../../../utils/src/codegraph/managed-runtime.ts";
-import { evaluateCodegraphNodeSupport, type CodegraphNodeSupport } from "../../../../../utils/src/codegraph/node-support.ts";
-import { ensureCodegraphProvisioned } from "../../../../../utils/src/codegraph/provision.ts";
-import { resolveCodegraphCommand } from "../../../../../utils/src/codegraph/resolve.ts";
-import { ensureCodegraphGitignored, prepareCodegraphWorkspace } from "../../../../../utils/src/codegraph/workspace.ts";
-import type {
-	CodegraphSessionStartDeps,
-	CodegraphSessionStartOutcome,
-	SessionStartWorkerOptions,
-	WorkerAction,
-} from "./hook-types.js";
-import {
-	resolveSessionStartCommand,
-	runSessionStartCodegraphCommand,
-	SESSION_START_COMMAND_TIMEOUT_MS,
-	sessionStartCodegraphEnv,
-	type CodegraphBootstrapConfig,
-} from "./session-start-command.js";
-import { DEFAULT_SESSION_START_COOLDOWN_MS } from "./session-start-cooldown.js";
-import { releaseSessionStartLock, sessionStartLockIsOwned, type SessionStartLock } from "./session-start-lock.js";
-import { appendSessionStartOutcome } from "./session-start-outcome.js";
-import { resolveSessionStartStatePaths } from "./session-start-paths.js";
-import { probeCodegraphProject, type CodegraphProjectState } from "./session-start-project.js";
-import {
-	finishWorkerFailure,
-	finishWorkerInitialization,
-	finishWorkerNeutral,
-	finishWorkerProjectState,
-	safeLogWorkerOutcome,
-	type WorkerResultContext,
-	type WorkerRunResult,
-} from "./session-start-worker-result.js";
-
-export const SESSION_START_CWD_ENV = "OMO_CODEGRAPH_SESSION_START_CWD";
-export const SESSION_START_LOCK_TOKEN_ENV = "OMO_CODEGRAPH_SESSION_START_LOCK_TOKEN";
-
-type WorkerContext = WorkerResultContext & {
-	readonly config: CodegraphBootstrapConfig;
-	readonly deps: CodegraphSessionStartDeps;
-	readonly env: Record<string, string | undefined>;
-	readonly probeProject: (projectRoot: string) => CodegraphProjectState;
-};
-
-const defaultDeps: CodegraphSessionStartDeps = {
-	ensureGitignored: ensureCodegraphGitignored,
-	ensureProvisioned: ensureCodegraphProvisioned,
-	managedInstallExists: hasCodegraphManagedInstall,
-	prepareWorkspace: prepareCodegraphWorkspace,
-	resolveCommand: resolveCodegraphCommand,
-	resolveManagedBin: resolvePinnedCodegraphBin,
-	runCommand: runSessionStartCodegraphCommand,
-};
-
-export async function runCodegraphSessionStartWorker(options: SessionStartWorkerOptions = {}): Promise<{ readonly action: WorkerAction }> {
-	const env = options.env ?? processEnv;
-	const homeDir = resolveHomeDir(env);
-	const projectRoot = options.cwd ?? env[SESSION_START_CWD_ENV] ?? processCwd();
-	const config = options.config ?? getCodexOmoConfig({ cwd: projectRoot, env, homeDir });
-	const lock = resolveWorkerLock(homeDir, projectRoot, env[SESSION_START_LOCK_TOKEN_ENV]);
-	if (lock !== null && !sessionStartLockIsOwned(lock)) {
-		const outcome = { action: "skipped-locked", projectRoot } satisfies CodegraphSessionStartOutcome;
-		safeLogWorkerOutcome(options.logOutcome ?? ((value) => appendSessionStartOutcome(homeDir, value)), outcome);
-		return { action: "skipped-locked" };
-	}
-
-	const customResolutionDeps = options.deps?.resolveCommand === undefined
-		? {}
-		: {
-			managedInstallExists: options.deps.managedInstallExists ?? (() => false),
-			resolveManagedBin: options.deps.resolveManagedBin ?? (() => null),
-		};
-	const context: WorkerContext = {
-		baseCooldownMs: config.codegraph?.session_start_cooldown_ms ?? DEFAULT_SESSION_START_COOLDOWN_MS,
-		config: {
-			...(config.codegraph ?? {}),
-			...(config.trustedCodegraphInstallDir === undefined ? {} : { trustedCodegraphInstallDir: config.trustedCodegraphInstallDir }),
-		},
-		deps: { ...defaultDeps, ...customResolutionDeps, ...options.deps },
-		env,
-		homeDir,
-		logOutcome: options.logOutcome ?? ((outcome) => appendSessionStartOutcome(homeDir, outcome)),
-		nowMs: () => options.nowMs ?? Date.now(),
-		probeProject: options.projectProbe ?? probeCodegraphProject,
-		projectRoot,
-	};
-
-	let result: WorkerRunResult;
-	if (config.codegraph?.enabled === false) {
-		result = finishWorkerNeutral("skipped-disabled", { projectRoot }, context);
-	} else {
-		const nodeSupport = evaluateCodegraphNodeSupport({ env, nodeVersion: options.nodeVersion });
-		result = await runBootstrap(context, nodeSupport);
-	}
-	if (lock !== null && result.releaseLock) releaseSessionStartLock(lock);
-	return { action: result.action };
-}
-
-async function runBootstrap(context: WorkerContext, nodeSupport: CodegraphNodeSupport): Promise<WorkerRunResult> {
-	try {
-		const projectState = context.probeProject(context.projectRoot);
-		const projectDecision = finishWorkerProjectState(projectState, context);
-		if (projectDecision !== null) return projectDecision;
-
-		const command = await resolveSessionStartCommand({
-			config: context.config,
-			deps: context.deps,
-			env: context.env,
-			homeDir: context.homeDir,
-			nodeSupport,
-		});
-		if (command.kind === "unavailable") {
-			return finishWorkerFailure("skipped-unavailable", "skipped-unavailable", {
-				error: command.error,
-				projectRoot: context.projectRoot,
-				source: command.source,
-			}, context);
-		}
-		if (command.kind === "unsupported-node") {
-			return finishWorkerFailure("skipped-unsupported-node", "skipped-unsupported-node", { projectRoot: context.projectRoot }, context);
-		}
-
-		context.deps.prepareWorkspace(context.projectRoot, { homeDir: context.homeDir });
-		context.deps.ensureGitignored(context.projectRoot);
-		const preparedState = context.probeProject(context.projectRoot);
-		const preparedDecision = finishWorkerProjectState(preparedState, context);
-		if (preparedDecision !== null) return preparedDecision;
-
-		const action = await context.deps.runCommand(
-			context.projectRoot,
-			command.resolution.command,
-			[...command.resolution.argsPrefix, "init"],
-			{ env: sessionStartCodegraphEnv(context.config, context.homeDir), timeoutMs: SESSION_START_COMMAND_TIMEOUT_MS },
-		);
-		if (action.timedOut) {
-			return finishWorkerFailure("failed", "timeout", {
-				error: "codegraph init timed out",
-				exitCode: action.exitCode,
-				projectRoot: context.projectRoot,
-				source: command.resolution.source,
-				timedOut: true,
-			}, context);
-		}
-		if (action.exitCode !== 0) {
-			return finishWorkerFailure("failed", "failed", {
-				error: `codegraph init exited ${action.exitCode}`,
-				exitCode: action.exitCode,
-				projectRoot: context.projectRoot,
-				source: command.resolution.source,
-				timedOut: false,
-			}, context);
-		}
-		return finishWorkerInitialization(context.probeProject(context.projectRoot), {
-			exitCode: action.exitCode,
-			source: command.resolution.source,
-		}, context);
-	} catch (error) {
-		return finishWorkerFailure("failed", "failed", {
-			error: error instanceof Error ? error.message : String(error),
-			projectRoot: context.projectRoot,
-		}, context);
-	}
-}
-
-function resolveWorkerLock(homeDir: string, projectRoot: string, token: string | undefined): SessionStartLock | null {
-	if (token === undefined || token.length === 0) return null;
-	return { path: resolveSessionStartStatePaths(homeDir, projectRoot).lockPath, token };
-}
-
-function resolveHomeDir(env: Record<string, string | undefined>): string {
-	return env["HOME"] ?? env["USERPROFILE"] ?? homedir();
-}

package/packages/omo-codex/plugin/components/codegraph/src/sweep-cli.ts

@@ -1,81 +0,0 @@
-import type { HookStdout } from "./hook-types.js";
-import {
-	sweepCodegraphZombies,
-	type CodegraphZombieProcess,
-	type SweepCodegraphZombiesOptions,
-	type SweepCodegraphZombiesResult,
-} from "../../../../../utils/src/codegraph/process-sweep.ts";
-
-export interface RunCodegraphSweepCliOptions extends SweepCodegraphZombiesOptions {
-	readonly argv?: readonly string[];
-	readonly stdout?: HookStdout;
-}
-
-interface SweepCliArgs {
-	readonly dryRun: boolean;
-	readonly force: boolean;
-	readonly roots: readonly string[];
-}
-
-export async function runCodegraphSweepCli(options: RunCodegraphSweepCliOptions = {}): Promise<number> {
-	const args = parseSweepCliArgs(options.argv ?? process.argv);
-	const result = await sweepCodegraphZombies({
-		...options,
-		dryRun: args.dryRun,
-		extraRoots: args.roots,
-		force: args.force,
-		...(args.roots.length > 0 ? { ownedRoots: args.roots } : {}),
-	});
-	writeSweepReport(options.stdout ?? process.stdout, result);
-	return result.action === "failed" ? 1 : 0;
-}
-
-function parseSweepCliArgs(argv: readonly string[]): SweepCliArgs {
-	const roots: string[] = [];
-	let dryRun = false;
-	let force = false;
-	for (let index = 3; index < argv.length; index += 1) {
-		const arg = argv[index];
-		if (arg === "--dry-run") {
-			dryRun = true;
-			continue;
-		}
-		if (arg === "--force") {
-			force = true;
-			continue;
-		}
-		if (arg === "--root") {
-			const value = argv[index + 1];
-			if (value !== undefined && value.trim().length > 0) roots.push(value);
-			index += 1;
-		}
-	}
-	return { dryRun, force, roots };
-}
-
-function writeSweepReport(stdout: HookStdout, result: SweepCodegraphZombiesResult): void {
-	stdout.write(`${JSON.stringify({
-		action: result.action,
-		candidates: result.candidates.map(formatProcess),
-		dryRun: result.dryRun,
-		failed: result.failed,
-		killed: result.killed.map(formatProcess),
-		ownedRoots: result.ownedRoots,
-		spared: result.spared.map(formatProcess),
-		stampFile: result.stampFile,
-	})}\n`);
-}
-
-function formatProcess(processInfo: CodegraphZombieProcess): {
-	readonly matchKind: string;
-	readonly matchedRoot: string;
-	readonly pid: number;
-	readonly ppid: number;
-} {
-	return {
-		matchKind: processInfo.matchKind,
-		matchedRoot: processInfo.matchedRoot,
-		pid: processInfo.pid,
-		ppid: processInfo.ppid,
-	};
-}

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

@@ -1,34 +0,0 @@
-import { describe, expect, it } from "bun:test";
-
-import { pruneCodegraphProjectStoresBestEffort } from "../src/cache-gc.ts";
-
-describe("CodeGraph cache GC wrapper", () => {
-	it("#given cache GC hits an expected filesystem race #when best-effort wrapper runs #then it logs and continues", () => {
-		const logs: string[] = [];
-		const error = Object.assign(new Error("project cache vanished"), { code: "ENOENT" });
-
-		pruneCodegraphProjectStoresBestEffort("/home/test", {
-			debugLog: (message) => logs.push(message),
-			prune: () => {
-				throw error;
-			},
-		});
-
-		expect(logs).toEqual(["CodeGraph cache GC skipped: project cache vanished"]);
-	});
-
-	it("#given cache GC hits an unknown code bug #when best-effort wrapper runs #then it rethrows", () => {
-		const logs: string[] = [];
-		const error = new Error("metadata invariant broken");
-
-		expect(() =>
-			pruneCodegraphProjectStoresBestEffort("/home/test", {
-				debugLog: (message) => logs.push(message),
-				prune: () => {
-					throw error;
-				},
-			}),
-		).toThrow("metadata invariant broken");
-		expect(logs).toEqual([]);
-	});
-});