oh-my-opencode 4.8.1 → 4.9.1

package/packages/omo-codex/plugin/components/git-bash/dist/codex-hook.js

@@ -0,0 +1,137 @@
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+const BASH_TOOL_NAME = "Bash";
+const REMINDER = "On Windows, prefer the OMO git_bash MCP for shell commands before using built-in exec_command. Use exec_command only when git_bash is unavailable or for non-shell operations.";
+export function parsePreToolUsePayload(raw) {
+    if (raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isPreToolUsePayload(parsed) ? parsed : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        return null;
+    }
+}
+export function parsePostCompactPayload(raw) {
+    if (raw.trim().length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return isPostCompactPayload(parsed) ? parsed : null;
+    }
+    catch (error) {
+        if (error instanceof SyntaxError)
+            return null;
+        return null;
+    }
+}
+export function applyGitBashPreToolUseReminder(payload, options = {}) {
+    if (payload.hook_event_name !== "PreToolUse")
+        return "";
+    if (payload.tool_name !== BASH_TOOL_NAME)
+        return "";
+    if (!isWindowsHost(options))
+        return "";
+    const markerPath = reminderMarkerPath(payload.session_id, options.pluginDataRoot);
+    if (hasReminderMarker(markerPath))
+        return "";
+    mkdirSync(dirname(markerPath), { recursive: true });
+    writeFileSync(markerPath, `${new Date().toISOString()}\n`);
+    const output = {
+        hookSpecificOutput: {
+            hookEventName: "PreToolUse",
+            additionalContext: REMINDER,
+        },
+    };
+    return `${JSON.stringify(output)}\n`;
+}
+export function applyGitBashPostCompactReset(payload, options = {}) {
+    if (payload.hook_event_name !== "PostCompact")
+        return "";
+    rmSync(reminderMarkerPath(payload.session_id, options.pluginDataRoot), { force: true });
+    return "";
+}
+export async function runGitBashHookCli(stdin, stdout, eventName = "pre-tool-use", options = {}) {
+    try {
+        const raw = await readAll(stdin);
+        const output = eventName === "post-compact" ? postCompactOutput(raw, options) : preToolUseOutput(raw, options);
+        if (output.length > 0)
+            stdout.write(output);
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return;
+        return;
+    }
+}
+function preToolUseOutput(raw, options) {
+    const payload = parsePreToolUsePayload(raw);
+    if (payload === null)
+        return "";
+    return applyGitBashPreToolUseReminder(payload, options);
+}
+function postCompactOutput(raw, options) {
+    const payload = parsePostCompactPayload(raw);
+    if (payload === null)
+        return "";
+    return applyGitBashPostCompactReset(payload, options);
+}
+function isWindowsHost(options) {
+    const platform = options.platform ?? process.platform;
+    if (platform === "win32")
+        return true;
+    const env = options.env ?? process.env;
+    return env["OS"] === "Windows_NT" || env["ComSpec"] !== undefined || env["SystemRoot"] !== undefined;
+}
+function hasReminderMarker(path) {
+    return existsSync(path);
+}
+function reminderMarkerPath(sessionId, pluginDataRoot) {
+    const root = pluginDataRoot ?? process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "omo-git-bash");
+    return join(root, "git-bash-reminder", `${safePathSegment(sessionId)}.seen`);
+}
+function safePathSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_");
+}
+function isPreToolUsePayload(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["hook_event_name"] === "PreToolUse" &&
+        typeof value["cwd"] === "string" &&
+        typeof value["model"] === "string" &&
+        typeof value["permission_mode"] === "string" &&
+        typeof value["session_id"] === "string" &&
+        typeof value["tool_name"] === "string" &&
+        typeof value["tool_use_id"] === "string" &&
+        (value["transcript_path"] === null || typeof value["transcript_path"] === "string") &&
+        typeof value["turn_id"] === "string" &&
+        Object.hasOwn(value, "tool_input"));
+}
+function isPostCompactPayload(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["hook_event_name"] === "PostCompact" &&
+        typeof value["session_id"] === "string" &&
+        (value["transcript_path"] === undefined ||
+            value["transcript_path"] === null ||
+            typeof value["transcript_path"] === "string") &&
+        (value["trigger"] === undefined || typeof value["trigger"] === "string"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readAll(stdin) {
+    return new Promise((resolve, reject) => {
+        let data = "";
+        stdin.setEncoding("utf8");
+        stdin.on("data", (chunk) => {
+            data += chunk instanceof Buffer ? chunk.toString() : String(chunk);
+        });
+        stdin.once("error", reject);
+        stdin.once("end", () => resolve(data));
+    });
+}

package/packages/omo-codex/plugin/components/git-bash/dist/index.d.ts

@@ -0,0 +1 @@
+export { applyGitBashPostCompactReset, applyGitBashPreToolUseReminder, parsePostCompactPayload, parsePreToolUsePayload, runGitBashHookCli, type GitBashHookOptions, type PostCompactPayload, type PreToolUsePayload, } from "./codex-hook.js";

package/packages/omo-codex/plugin/components/git-bash/dist/index.js

@@ -0,0 +1 @@
+export { applyGitBashPostCompactReset, applyGitBashPreToolUseReminder, parsePostCompactPayload, parsePreToolUsePayload, runGitBashHookCli, } from "./codex-hook.js";

package/packages/omo-codex/plugin/components/git-bash/hooks/hooks.json

@@ -8,7 +8,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook pre-tool-use",
 						"timeout": 5,
-						"statusMessage": "LazyCodex(0.1.0): Recommending Git Bash Mcp"
+						"statusMessage": "LazyCodex(4.9.1): Recommending Git Bash Mcp"
 					}
 				]
 			}
@@ -20,7 +20,7 @@
 						"type": "command",
 						"command": "node \"${PLUGIN_ROOT}/dist/cli.js\" hook post-compact",
 						"timeout": 5,
-						"statusMessage": "LazyCodex(0.1.0): Resetting Git Bash Mcp Reminder"
+						"statusMessage": "LazyCodex(4.9.1): Resetting Git Bash Mcp Reminder"
 					}
 				]
 			}

package/packages/omo-codex/plugin/components/git-bash/package.json

@@ -1,13 +1,16 @@
 {
 	"name": "@sisyphuslabs/codex-git-bash-hook",
-	"version": "0.1.0",
+	"version": "4.9.1",
 	"description": "Codex hook component that reminds Windows sessions to prefer the OMO git_bash MCP.",
 	"type": "module",
 	"private": true,
 	"bin": {
 		"omo-git-bash-hook": "./dist/cli.js"
 	},
-	"files": ["dist", "hooks"],
+	"files": [
+		"dist",
+		"hooks"
+	],
 	"scripts": {
 		"build": "tsc -p tsconfig.build.json",
 		"test": "bun test test/*.test.ts",

package/packages/omo-codex/plugin/components/lsp/.mcp.json

@@ -2,7 +2,7 @@
 	"mcpServers": {
 		"lsp": {
 			"command": "node",
-			"args": ["../../../../lsp-tools-mcp/dist/cli.js", "mcp"],
+			"args": ["../../../../lsp-daemon/dist/cli.js", "mcp"],
 			"cwd": "."
 		}
 	}

package/packages/omo-codex/plugin/components/lsp/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/packages/omo-codex/plugin/components/lsp/dist/cli.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { createRequire } from "node:module";
+import { argv, execPath, stderr } from "node:process";
+import { runPostCompactHookCli, runPostToolUseHookCli } from "./codex-hook-cli.js";
+const require = createRequire(import.meta.url);
+const PACKAGE_LSP_MCP_CLI = "@code-yeongyu/lsp-daemon/dist/cli.js";
+async function main() {
+    const [command = "mcp", subcommand = ""] = argv.slice(2);
+    if (command === "hook" && subcommand === "post-tool-use") {
+        await runPostToolUseHookCli();
+        return;
+    }
+    if (command === "hook" && subcommand === "post-compact") {
+        await runPostCompactHookCli();
+        return;
+    }
+    if (command === "mcp") {
+        await runPackageLspMcpCli();
+        return;
+    }
+    stderr.write("Usage: omo-lsp [mcp | hook post-tool-use | hook post-compact]\n");
+    process.exitCode = 2;
+}
+main().catch((error) => {
+    stderr.write(`${error instanceof Error ? (error.stack ?? error.message) : String(error)}\n`);
+    process.exitCode = 1;
+});
+async function runPackageLspMcpCli() {
+    const cliPath = require.resolve(PACKAGE_LSP_MCP_CLI);
+    const child = spawn(execPath, [cliPath, "mcp"], { stdio: "inherit" });
+    await new Promise((resolve, reject) => {
+        child.once("error", reject);
+        child.once("exit", (code, signal) => {
+            if (code !== null && code !== 0)
+                process.exitCode = code;
+            if (code === null && signal !== null)
+                process.exitCode = 1;
+            resolve();
+        });
+    });
+}

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook-cli.d.ts

@@ -0,0 +1,2 @@
+export declare function runPostToolUseHookCli(stdin?: NodeJS.ReadStream): Promise<void>;
+export declare function runPostCompactHookCli(stdin?: NodeJS.ReadStream): Promise<void>;

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook-cli.js

@@ -0,0 +1,40 @@
+import { stdin as processStdin } from "node:process";
+import { disposeDefaultLspManager } from "@code-yeongyu/lsp-daemon";
+import { isRecord, runLspPostCompactHook, runLspPostToolUseHook } from "./codex-hook.js";
+export async function runPostToolUseHookCli(stdin = processStdin) {
+    await runHookCli((input) => runLspPostToolUseHook(input), stdin);
+}
+export async function runPostCompactHookCli(stdin = processStdin) {
+    await runHookCli((input) => runLspPostCompactHook(input), stdin);
+}
+async function runHookCli(runHook, stdin) {
+    try {
+        const raw = await readStdin(stdin);
+        if (!raw.trim())
+            return;
+        let parsed;
+        try {
+            parsed = JSON.parse(raw);
+        }
+        catch (error) {
+            if (error instanceof SyntaxError)
+                return;
+            throw error;
+        }
+        const input = isRecord(parsed) ? parsed : {};
+        const output = await runHook(input);
+        if (output)
+            process.stdout.write(output);
+    }
+    finally {
+        await disposeDefaultLspManager();
+    }
+}
+async function readStdin(stdin) {
+    stdin.setEncoding("utf8");
+    let raw = "";
+    for await (const chunk of stdin) {
+        raw += chunk;
+    }
+    return raw;
+}

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook.d.ts

@@ -0,0 +1,16 @@
+export { extractMutatedFilePaths } from "./mutated-file-paths.js";
+export type DiagnosticsRunner = (filePath: string) => Promise<string>;
+export interface CodexPostToolUseInput {
+    session_id?: unknown;
+    tool_name?: unknown;
+    tool_input?: unknown;
+    tool_response?: unknown;
+    transcript_path?: unknown;
+}
+export interface CodexPostCompactInput {
+    session_id?: unknown;
+}
+export declare function runLspDiagnosticsText(filePath: string): Promise<string>;
+export declare function runLspPostToolUseHook(input: CodexPostToolUseInput, runDiagnostics?: DiagnosticsRunner): Promise<string>;
+export declare function runLspPostCompactHook(input: CodexPostCompactInput): Promise<string>;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;

package/packages/omo-codex/plugin/components/lsp/dist/codex-hook.js

@@ -0,0 +1,180 @@
+import { readFileSync } from "node:fs";
+import { callDiagnosticsViaDaemon, currentRequestContext } from "@code-yeongyu/lsp-daemon";
+import { isLspDaemonUnreachableDiagnostics, isUnavailableLspDiagnostics, markLspSessionCompacted, recordLspDiagnosticsObservations, sessionIdFrom, shouldSkipUnavailableLspDiagnostics, } from "./lsp-session-state.js";
+import { extractMutatedFilePaths } from "./mutated-file-paths.js";
+export { extractMutatedFilePaths } from "./mutated-file-paths.js";
+const CLEAN_DIAGNOSTICS_TEXT = "No diagnostics found";
+const UNSUPPORTED_EXTENSION_TEXT = "No LSP server configured for extension:";
+const DIAGNOSTIC_START_PATTERN = /(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/g;
+const DIAGNOSTIC_CHUNK_PATTERN = /^(?:error|warning|information|hint)\[[^\]\r\n]+\] \(\d+\) at \d+:\d+:/;
+const DEFAULT_MAX_HOOK_FEEDBACK_CHARS = 8000;
+const CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS = 1200;
+const MAX_CONCURRENT_DIAGNOSTICS = 4;
+const CONTEXT_PRESSURE_MARKERS = [
+    "context compacted",
+    "context_length_exceeded",
+    "skill descriptions were shortened",
+    "context_too_large",
+    "codex ran out of room in the model's context window",
+    "your input exceeds the context window",
+    "long threads and multiple compactions",
+];
+export async function runLspDiagnosticsText(filePath) {
+    const result = await callDiagnosticsViaDaemon(filePath, { context: currentRequestContext() });
+    return result.content.map((block) => block.text).join("\n");
+}
+export async function runLspPostToolUseHook(input, runDiagnostics = runLspDiagnosticsText) {
+    const sessionId = sessionIdFrom(input);
+    const filePaths = extractMutatedFilePaths(input).filter((filePath) => !shouldSkipUnavailableLspDiagnostics(filePath, sessionId));
+    if (filePaths.length === 0)
+        return "";
+    const blocks = [];
+    const observations = [];
+    for (const { filePath, diagnostics } of await collectDiagnostics(filePaths, runDiagnostics)) {
+        // A daemon outage is transient (connect-or-spawn retries on the next request);
+        // recording it would silence this extension for the rest of the session.
+        if (isLspDaemonUnreachableDiagnostics(diagnostics))
+            continue;
+        const unavailable = isUnavailableLspDiagnostics(diagnostics);
+        observations.push({ filePath, unavailable });
+        if (isCleanDiagnostics(diagnostics))
+            continue;
+        if (unavailable)
+            continue;
+        blocks.push({ filePath, diagnostics });
+    }
+    recordLspDiagnosticsObservations(sessionId, observations);
+    if (blocks.length === 0)
+        return "";
+    const rawReason = blocks.map(formatDiagnosticBlock).join("\n\n");
+    const reason = limitHookText(rawReason, hookFeedbackLimit(input.transcript_path));
+    const output = {
+        decision: "block",
+        reason,
+        hookSpecificOutput: {
+            hookEventName: "PostToolUse",
+            additionalContext: reason,
+        },
+    };
+    return `${JSON.stringify(output)}\n`;
+}
+export async function runLspPostCompactHook(input) {
+    markLspSessionCompacted(sessionIdFrom(input));
+    return "";
+}
+async function collectDiagnostics(filePaths, runDiagnostics) {
+    const results = [];
+    let nextIndex = 0;
+    const workerCount = Math.min(MAX_CONCURRENT_DIAGNOSTICS, filePaths.length);
+    async function worker() {
+        for (;;) {
+            const index = nextIndex;
+            nextIndex += 1;
+            const filePath = filePaths[index];
+            if (filePath === undefined)
+                return;
+            results[index] = { filePath, diagnostics: await collectFileDiagnostics(filePath, runDiagnostics) };
+        }
+    }
+    await Promise.all(Array.from({ length: workerCount }, () => worker()));
+    return results;
+}
+async function collectFileDiagnostics(filePath, runDiagnostics) {
+    try {
+        return (await runDiagnostics(filePath)).trim();
+    }
+    catch (error) {
+        return formatDiagnosticsError(error);
+    }
+}
+function formatDiagnosticsError(error) {
+    if (error instanceof Error) {
+        const message = error.message.trim();
+        if (message.length > 0)
+            return message;
+    }
+    return String(error).trim();
+}
+function formatDiagnosticBlock({ filePath, diagnostics }) {
+    return `LSP diagnostics after editing ${filePath}:\n\n${formatDiagnosticsForDisplay(diagnostics)}`;
+}
+function formatDiagnosticsForDisplay(diagnostics) {
+    const chunks = splitDiagnosticChunks(diagnostics);
+    if (!chunks.some(isDiagnosticChunk))
+        return chunks.join("\n").trim();
+    return chunks.map(formatDiagnosticChunk).join("\n");
+}
+function splitDiagnosticChunks(diagnostics) {
+    const normalized = diagnostics.replace(/\r\n/g, "\n").replace(/\r/g, "\n").trim();
+    if (normalized.length === 0)
+        return [];
+    const matches = Array.from(normalized.matchAll(DIAGNOSTIC_START_PATTERN));
+    const firstMatch = matches[0];
+    if (firstMatch?.index === undefined)
+        return [normalized];
+    const chunks = [];
+    const leadingText = normalized.slice(0, firstMatch.index).trim();
+    if (leadingText.length > 0)
+        chunks.push(leadingText);
+    for (const [index, match] of matches.entries()) {
+        if (match.index === undefined)
+            continue;
+        const nextMatch = matches[index + 1];
+        const end = nextMatch?.index ?? normalized.length;
+        const chunk = normalized.slice(match.index, end).trim();
+        if (chunk.length > 0)
+            chunks.push(chunk);
+    }
+    return chunks;
+}
+function formatDiagnosticChunk(chunk) {
+    const lines = chunk.split("\n");
+    const firstLine = lines[0];
+    if (firstLine === undefined)
+        return "";
+    if (!isDiagnosticChunk(firstLine))
+        return chunk;
+    const followingLines = lines.slice(1).map((line) => `  ${line}`);
+    return [`- ${firstLine}`, ...followingLines].join("\n");
+}
+function isDiagnosticChunk(chunk) {
+    return DIAGNOSTIC_CHUNK_PATTERN.test(chunk);
+}
+function hookFeedbackLimit(transcriptPath) {
+    return isContextPressureTranscript(transcriptPath)
+        ? CONTEXT_PRESSURE_MAX_HOOK_FEEDBACK_CHARS
+        : DEFAULT_MAX_HOOK_FEEDBACK_CHARS;
+}
+function isContextPressureTranscript(transcriptPath) {
+    if (typeof transcriptPath !== "string")
+        return false;
+    try {
+        return hasContextPressureMarker(readFileSync(transcriptPath, "utf8"));
+    }
+    catch (error) {
+        if (error instanceof Error)
+            return false;
+        throw error;
+    }
+}
+function hasContextPressureMarker(text) {
+    const normalizedText = text.toLowerCase();
+    return CONTEXT_PRESSURE_MARKERS.some((marker) => normalizedText.includes(marker));
+}
+function limitHookText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    const marker = `\n\n[Truncated hook output to ${maxChars} chars to avoid Codex context overflow.]`;
+    if (marker.length >= maxChars)
+        return marker.slice(0, maxChars);
+    const head = text.slice(0, maxChars - marker.length).replace(/[ \t\r\n]+$/, "");
+    return `${head}${marker}`;
+}
+function isCleanDiagnostics(diagnostics) {
+    return (diagnostics.length === 0 ||
+        diagnostics === CLEAN_DIAGNOSTICS_TEXT ||
+        diagnostics.startsWith(UNSUPPORTED_EXTENSION_TEXT));
+}
+export function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/lsp/dist/lsp-session-state.d.ts

@@ -0,0 +1,12 @@
+export interface DiagnosticsObservation {
+    readonly filePath: string;
+    readonly unavailable: boolean;
+}
+export declare function sessionIdFrom(input: {
+    readonly session_id?: unknown;
+}): string | undefined;
+export declare function shouldSkipUnavailableLspDiagnostics(filePath: string, sessionId: string | undefined): boolean;
+export declare function recordLspDiagnosticsObservations(sessionId: string | undefined, observations: readonly DiagnosticsObservation[]): void;
+export declare function markLspSessionCompacted(sessionId: string | undefined): void;
+export declare function isUnavailableLspDiagnostics(diagnostics: string): boolean;
+export declare function isLspDaemonUnreachableDiagnostics(diagnostics: string): boolean;

package/packages/omo-codex/plugin/components/lsp/dist/lsp-session-state.js

@@ -0,0 +1,95 @@
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, extname, join } from "node:path";
+export function sessionIdFrom(input) {
+    return typeof input.session_id === "string" && input.session_id.length > 0 ? input.session_id : undefined;
+}
+export function shouldSkipUnavailableLspDiagnostics(filePath, sessionId) {
+    if (sessionId === undefined)
+        return false;
+    const state = readSessionState(sessionStatePath(sessionId));
+    const extension = extensionKey(filePath);
+    return (extension !== undefined &&
+        state.postCompactProbePending !== true &&
+        state.unavailableExtensions.includes(extension));
+}
+export function recordLspDiagnosticsObservations(sessionId, observations) {
+    if (sessionId === undefined || observations.length === 0)
+        return;
+    const state = readSessionState(sessionStatePath(sessionId));
+    const unavailableExtensions = new Set(state.unavailableExtensions);
+    for (const observation of observations) {
+        const extension = extensionKey(observation.filePath);
+        if (extension === undefined)
+            continue;
+        if (observation.unavailable) {
+            unavailableExtensions.add(extension);
+        }
+        else {
+            unavailableExtensions.delete(extension);
+        }
+    }
+    writeSessionState(sessionStatePath(sessionId), { unavailableExtensions: [...unavailableExtensions].sort() });
+}
+export function markLspSessionCompacted(sessionId) {
+    if (sessionId === undefined)
+        return;
+    const state = readSessionState(sessionStatePath(sessionId));
+    if (state.unavailableExtensions.length === 0)
+        return;
+    writeSessionState(sessionStatePath(sessionId), {
+        unavailableExtensions: state.unavailableExtensions,
+        postCompactProbePending: true,
+    });
+}
+export function isUnavailableLspDiagnostics(diagnostics) {
+    const normalized = diagnostics.trim();
+    return (normalized.includes("LSP request timeout (method: initialize)") ||
+        normalized.includes("LSP server is still initializing") ||
+        normalized.includes("NOT INSTALLED") ||
+        normalized.includes("Command not found:"));
+}
+export function isLspDaemonUnreachableDiagnostics(diagnostics) {
+    return diagnostics.includes("LSP daemon unreachable");
+}
+function sessionStatePath(sessionId) {
+    const root = process.env["PLUGIN_DATA"] ?? join(homedir(), ".codex", "codex-lsp");
+    return join(root, "sessions", `${safePathSegment(sessionId)}.json`);
+}
+function readSessionState(path) {
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        if (isLspSessionState(parsed))
+            return parsed;
+        return emptyState();
+    }
+    catch (error) {
+        if (error instanceof SyntaxError || (isRecord(error) && error["code"] === "ENOENT"))
+            return emptyState();
+        throw error;
+    }
+}
+function writeSessionState(path, state) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, `${JSON.stringify(state)}\n`);
+}
+function emptyState() {
+    return { unavailableExtensions: [] };
+}
+function extensionKey(filePath) {
+    const extension = extname(filePath).toLowerCase();
+    return extension.length === 0 ? undefined : extension;
+}
+function safePathSegment(value) {
+    return value.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 120) || "unknown-session";
+}
+function isLspSessionState(value) {
+    if (!isRecord(value) || !Array.isArray(value["unavailableExtensions"]))
+        return false;
+    const postCompactProbePending = value["postCompactProbePending"];
+    return (value["unavailableExtensions"].every((item) => typeof item === "string") &&
+        (postCompactProbePending === undefined || typeof postCompactProbePending === "boolean"));
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/omo-codex/plugin/components/lsp/dist/mutated-file-paths.d.ts

@@ -0,0 +1,6 @@
+export interface MutatedFileInput {
+    readonly tool_name?: unknown;
+    readonly tool_input?: unknown;
+    readonly tool_response?: unknown;
+}
+export declare function extractMutatedFilePaths(input: MutatedFileInput): string[];

package/packages/omo-codex/plugin/components/lsp/dist/mutated-file-paths.js

@@ -0,0 +1,79 @@
+const MUTATION_TOOL_NAMES = new Set(["apply_patch", "write", "edit", "multiedit", "multi_edit"]);
+export function extractMutatedFilePaths(input) {
+    if (!isMutationTool(input.tool_name))
+        return [];
+    if (isFailedToolResponse(input.tool_response))
+        return [];
+    const toolInput = isRecord(input.tool_input) ? input.tool_input : {};
+    const paths = new Set();
+    addStringValue(paths, toolInput["path"]);
+    addStringValue(paths, toolInput["filePath"]);
+    addStringValue(paths, toolInput["file_path"]);
+    addStringArray(paths, toolInput["paths"]);
+    addStringArray(paths, toolInput["filePaths"]);
+    addStringArray(paths, toolInput["file_paths"]);
+    addPatchPayloads(paths, toolInput);
+    addPatchFiles(paths, toolInput["files"]);
+    addPatchFiles(paths, toolInput["changes"]);
+    return [...paths];
+}
+function isMutationTool(value) {
+    if (typeof value !== "string")
+        return false;
+    return MUTATION_TOOL_NAMES.has(value.toLowerCase());
+}
+function isFailedToolResponse(value) {
+    if (!isRecord(value))
+        return false;
+    return (value["isError"] === true || value["is_error"] === true || value["error"] === true || value["status"] === "error");
+}
+function addStringValue(paths, value) {
+    if (typeof value === "string" && value.length > 0) {
+        paths.add(value);
+    }
+}
+function addStringArray(paths, value) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value) {
+        addStringValue(paths, item);
+    }
+}
+function addPatchPayloads(paths, input) {
+    addPatchInput(paths, input["input"]);
+    addPatchInput(paths, input["patch"]);
+    addPatchInput(paths, input["command"]);
+}
+function addPatchInput(paths, value) {
+    if (typeof value !== "string")
+        return;
+    for (const line of value.split("\n")) {
+        const path = extractPatchHeaderPath(line);
+        if (path !== undefined)
+            paths.add(path);
+    }
+}
+function extractPatchHeaderPath(line) {
+    const prefixes = ["*** Add File: ", "*** Update File: ", "*** Move to: "];
+    for (const prefix of prefixes) {
+        if (line.startsWith(prefix))
+            return line.slice(prefix.length).trim();
+    }
+    return undefined;
+}
+function addPatchFiles(paths, value) {
+    if (!Array.isArray(value))
+        return;
+    for (const item of value) {
+        if (!isRecord(item))
+            continue;
+        addStringValue(paths, item["path"]);
+        addStringValue(paths, item["filePath"]);
+        addStringValue(paths, item["file_path"]);
+        addStringValue(paths, item["movePath"]);
+        addStringValue(paths, item["move_path"]);
+    }
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}