oh-my-opencode 4.8.1 → 4.9.1

package/packages/lsp-tools-mcp/dist/lsp/server-definitions.js

@@ -40,6 +40,9 @@ export const LSP_INSTALL_HINTS = {
     "haskell-language-server": "ghcup install hls",
     bash: "npm install -g bash-language-server",
     "kotlin-ls": "See https://github.com/Kotlin/kotlin-lsp",
+    julials: "julia -e 'using Pkg; Pkg.add(\"LanguageServer\")'",
+    razor: "Razor runs through the Roslyn language server (cohosting). " +
+        "Install: dotnet tool install -g roslyn-language-server --prerelease (requires v5.8.0+). See https://github.com/dotnet/razor",
 };
 export const BUILTIN_SERVERS = {
     typescript: {
@@ -133,6 +136,14 @@ export const BUILTIN_SERVERS = {
         extensions: [".hs", ".lhs"],
     },
     "kotlin-ls": { command: ["kotlin-lsp"], extensions: [".kt", ".kts"] },
+    julials: {
+        command: ["julia", "--startup-file=no", "--history-file=no", "-e", "using LanguageServer; runserver()"],
+        extensions: [".jl"],
+    },
+    razor: {
+        command: ["roslyn-language-server", "--stdio"],
+        extensions: [".razor", ".cshtml"],
+    },
 };
 export const AUTO_INSTALLABLE_SERVERS = {
     typescript: ["npm", "install", "-g", "typescript-language-server", "typescript"],
@@ -155,4 +166,5 @@ export const AUTO_INSTALLABLE_SERVERS = {
     ty: ["pip", "install", "ty"],
     "ruby-lsp": ["gem", "install", "ruby-lsp"],
     "ocaml-lsp": ["opam", "install", "ocaml-lsp-server"],
+    julials: ["julia", "-e", 'using Pkg; Pkg.add("LanguageServer")'],
 };

package/packages/lsp-tools-mcp/dist/lsp/server-install-state.d.ts

@@ -0,0 +1,12 @@
+export type InstallDecision = "declined" | "allowed";
+export interface InstallDecisionRecord {
+    readonly decision: InstallDecision;
+    readonly decidedAt: string;
+}
+type InstallDecisions = Record<string, InstallDecisionRecord>;
+export declare function getInstallDecisionsPath(): string;
+export declare function loadInstallDecisions(): InstallDecisions;
+export declare function loadInstallDecision(serverId: string): InstallDecisionRecord | undefined;
+export declare function recordInstallDecision(serverId: string, decision: InstallDecision, decidedAt?: string): void;
+export declare function isInstallDecision(value: unknown): value is InstallDecision;
+export {};

package/packages/lsp-tools-mcp/dist/lsp/server-install-state.js

@@ -0,0 +1,51 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join } from "node:path";
+import { contextEnv } from "../request-context.js";
+export function getInstallDecisionsPath() {
+    const override = contextEnv("LSP_TOOLS_MCP_INSTALL_DECISIONS");
+    if (!override)
+        return join(homedir(), ".codex", "lsp-install-decisions.json");
+    return isAbsolute(override) ? override : join(homedir(), override);
+}
+export function loadInstallDecisions() {
+    const path = getInstallDecisionsPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf8"));
+        return isInstallDecisions(parsed) ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+export function loadInstallDecision(serverId) {
+    return loadInstallDecisions()[serverId];
+}
+export function recordInstallDecision(serverId, decision, decidedAt = new Date().toISOString()) {
+    const decisions = loadInstallDecisions();
+    decisions[serverId] = { decision, decidedAt };
+    writeInstallDecisions(decisions);
+}
+export function isInstallDecision(value) {
+    return value === "declined" || value === "allowed";
+}
+function writeInstallDecisions(decisions) {
+    const path = getInstallDecisionsPath();
+    mkdirSync(dirname(path), { recursive: true });
+    const tmpPath = `${path}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(decisions, null, 2)}\n`, "utf8");
+    renameSync(tmpPath, path);
+}
+function isInstallDecisions(value) {
+    return isRecord(value) && Object.values(value).every(isInstallDecisionRecord);
+}
+function isInstallDecisionRecord(value) {
+    if (!isRecord(value))
+        return false;
+    return isInstallDecision(value["decision"]) && typeof value["decidedAt"] === "string";
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/lsp-tools-mcp/dist/lsp/workspace-edit.js

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync, realpathSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname, isAbsolute, relative, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { contextCwd } from "../request-context.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -76,7 +77,7 @@ export function applyWorkspaceEdit(edit, options = {}) {
         return { success: false, filesModified: [], totalEdits: 0, errors: ["No edit provided"] };
     }
     const result = { success: true, filesModified: [], totalEdits: 0, errors: [] };
-    const workspaceRoot = realpathSync(options.workspaceRoot ?? process.cwd());
+    const workspaceRoot = realpathSync(options.workspaceRoot ?? contextCwd());
     if (edit.changes) {
         for (const [uri, edits] of Object.entries(edit.changes)) {
             const validatedPath = uriToWorkspacePath(uri, workspaceRoot);

package/packages/lsp-tools-mcp/dist/request-context.d.ts

@@ -0,0 +1,7 @@
+export interface RequestContext {
+    cwd?: string;
+    env?: Record<string, string>;
+}
+export declare function runWithRequestContext<T>(context: RequestContext, fn: () => T): T;
+export declare function contextCwd(): string;
+export declare function contextEnv(key: string): string | undefined;

package/packages/lsp-tools-mcp/dist/request-context.js

@@ -0,0 +1,14 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+export function runWithRequestContext(context, fn) {
+    return storage.run(context, fn);
+}
+export function contextCwd() {
+    return storage.getStore()?.cwd ?? process.cwd();
+}
+export function contextEnv(key) {
+    const store = storage.getStore();
+    if (store?.env)
+        return store.env[key];
+    return process.env[key];
+}

package/packages/lsp-tools-mcp/dist/tools.js

@@ -1,13 +1,16 @@
 import { resolve } from "node:path";
 import { isDirectoryPath, withLspClient } from "./lsp/client-wrapper.js";
+import { getMergedServers } from "./lsp/config-loader.js";
 import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_REFERENCES, DEFAULT_MAX_SYMBOLS } from "./lsp/constants.js";
 import { aggregateDiagnosticsForDirectory } from "./lsp/directory-diagnostics.js";
 import { filterDiagnosticsBySeverity, formatApplyResult, formatDiagnostic, formatDocumentSymbol, formatLocation, formatPrepareRenameResult, formatSymbolInfo, } from "./lsp/formatters.js";
 import { inferExtensionFromDirectory } from "./lsp/infer-extension.js";
 import { getLspManager } from "./lsp/manager.js";
+import { isInstallDecision, recordInstallDecision } from "./lsp/server-install-state.js";
 import { getAllServers } from "./lsp/server-resolution.js";
 import { applyWorkspaceEdit } from "./lsp/workspace-edit.js";
 import { missingDependencyResult } from "./missing-dependency-result.js";
+import { contextCwd } from "./request-context.js";
 const objectSchema = (properties, required = []) => ({
     type: "object",
     properties,
@@ -94,7 +97,7 @@ export async function executeLspDiagnostics(params, signal) {
     const filePath = requireString(params, "filePath");
     const severity = severityFilter(params);
     try {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         if (isDirectoryPath(absPath)) {
             const extension = inferExtensionFromDirectory(absPath);
             if (!extension) {
@@ -338,6 +341,28 @@ async function executeLspRename(params, signal) {
         throw error;
     }
 }
+async function executeLspInstallDecision(params) {
+    const serverId = requireString(params, "server_id");
+    const decision = params["decision"];
+    if (!isInstallDecision(decision)) {
+        return text(`Invalid decision '${String(decision)}'. Expected "declined" or "allowed".`, { serverId, errorKind: "invalid_decision" }, true);
+    }
+    const serverIds = [...new Set(getMergedServers().map((server) => server.id))];
+    if (!serverIds.includes(serverId)) {
+        const preview = serverIds.slice(0, 20).join(", ");
+        return text(`Unknown LSP server '${serverId}'. Known servers: ${preview}${serverIds.length > 20 ? "..." : ""}`, { serverId, errorKind: "unknown_server" }, true);
+    }
+    recordInstallDecision(serverId, decision);
+    return text(`Recorded install decision for '${serverId}': ${decision}. ${decisionFollowUp(decision)}`, {
+        serverId,
+        decision,
+    });
+}
+function decisionFollowUp(decision) {
+    return decision === "declined"
+        ? "Future LSP lookups for this server stay quiet; proceed without LSP."
+        : "Future LSP lookups keep install instructions without asking the user.";
+}
 export async function executeLspTool(name, params, signal) {
     const tool = LSP_MCP_TOOLS.find((candidate) => matchesToolName(candidate, name));
     if (!tool)
@@ -441,4 +466,22 @@ export const LSP_MCP_TOOLS = [
         }, ["filePath", "line", "character", "newName"]),
         execute: executeLspRename,
     },
+    {
+        name: "install_decision",
+        aliases: ["lsp_install_decision"],
+        title: "LSP Install Decision",
+        description: "Record whether the user allowed or declined installing a missing LSP server. Record 'declined' when the user declines, or has not explicitly asked for LSP installation, to silence future prompts.",
+        inputSchema: objectSchema({
+            server_id: {
+                type: "string",
+                description: "The LSP server id from the not-installed message (e.g. 'rust').",
+            },
+            decision: {
+                type: "string",
+                enum: ["declined", "allowed"],
+                description: "'declined' silences future prompts; 'allowed' pre-authorizes installation.",
+            },
+        }, ["server_id", "decision"]),
+        execute: executeLspInstallDecision,
+    },
 ];

package/packages/omo-codex/plugin/.codex-plugin/plugin.json

@@ -1,35 +1,48 @@
 {
-	"name": "omo",
-	"version": "0.1.0",
-	"description": "One Codex plugin namespace for Yeongyu's local Codex components.",
-	"author": {
-		"name": "Yeongyu Kim",
-		"email": "yeongyu@users.noreply.github.com",
-		"url": "https://github.com/code-yeongyu"
-	},
-	"homepage": "https://github.com/sisyphuslabs/omo",
-	"repository": "https://github.com/sisyphuslabs/omo",
-	"license": "MIT",
-	"keywords": ["codex", "codex-plugin", "omo", "hooks", "mcp", "skills"],
-	"skills": "./skills/",
-	"hooks": "./hooks/hooks.json",
-	"mcpServers": "./.mcp.json",
-	"interface": {
-		"displayName": "OMO",
-		"shortDescription": "Unified local Codex components",
-		"longDescription": "OMO exposes local Codex Rules, Comment Checker, Git Bash, LSP, Ultrawork, ulw-loop, start-work continuation, and telemetry components as one plugin namespace while keeping each component isolated under components/ for maintenance.",
-		"developerName": "Yeongyu Kim",
-		"category": "Developer Tools",
-		"capabilities": ["Hooks", "MCP Tools", "Code Intelligence", "Workflow", "Context Injection"],
-		"websiteURL": "https://github.com/sisyphuslabs/omo",
-		"privacyPolicyURL": "https://github.com/sisyphuslabs/omo#privacy",
-		"termsOfServiceURL": "https://github.com/sisyphuslabs/omo#license",
-		"defaultPrompt": [
-			"Use OMO LSP diagnostics on this workspace.",
-			"Show which OMO rules matched this file.",
-			"ulw: run this change with evidence."
-		],
-		"brandColor": "#7C3AED",
-		"screenshots": []
-	}
+  "name": "omo",
+  "version": "4.9.1",
+  "description": "One Codex plugin namespace for Yeongyu's local Codex components.",
+  "author": {
+    "name": "Yeongyu Kim",
+    "email": "yeongyu@users.noreply.github.com",
+    "url": "https://github.com/code-yeongyu"
+  },
+  "homepage": "https://github.com/sisyphuslabs/omo",
+  "repository": "https://github.com/sisyphuslabs/omo",
+  "license": "MIT",
+  "keywords": [
+    "codex",
+    "codex-plugin",
+    "omo",
+    "hooks",
+    "mcp",
+    "skills"
+  ],
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json",
+  "mcpServers": "./.mcp.json",
+  "interface": {
+    "displayName": "OMO",
+    "shortDescription": "Unified local Codex components",
+    "longDescription": "OMO exposes local Codex Rules, Comment Checker, Git Bash, LSP, Ultrawork, ulw-loop, start-work continuation, and telemetry components as one plugin namespace while keeping each component isolated under components/ for maintenance.",
+    "developerName": "Yeongyu Kim",
+    "category": "Developer Tools",
+    "capabilities": [
+      "Hooks",
+      "MCP Tools",
+      "Code Intelligence",
+      "Workflow",
+      "Context Injection"
+    ],
+    "websiteURL": "https://github.com/sisyphuslabs/omo",
+    "privacyPolicyURL": "https://github.com/sisyphuslabs/omo#privacy",
+    "termsOfServiceURL": "https://github.com/sisyphuslabs/omo#license",
+    "defaultPrompt": [
+      "Use OMO LSP diagnostics on this workspace.",
+      "Show which OMO rules matched this file.",
+      "ulw: run this change with evidence."
+    ],
+    "brandColor": "#7C3AED",
+    "screenshots": []
+  }
 }

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

@@ -18,7 +18,7 @@
 		},
 		"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/comment-checker/dist/apply-patch.d.ts

@@ -0,0 +1,7 @@
+import type { CommentCheckRequest } from "./types.js";
+export declare function extractApplyPatchRequests(event: {
+    details?: unknown;
+    input: Record<string, unknown>;
+    toolName: string;
+}): CommentCheckRequest[];
+export declare function parseApplyPatchRequests(patch: string, sourceToolName?: string): CommentCheckRequest[];

package/packages/omo-codex/plugin/components/comment-checker/dist/apply-patch.js

@@ -0,0 +1,173 @@
+import { getString, isRecord } from "./record.js";
+export function extractApplyPatchRequests(event) {
+    const metadataRequests = extractApplyPatchMetadataRequests(event.details, event.toolName);
+    if (metadataRequests.length > 0)
+        return metadataRequests;
+    const patch = getString(event.input, ["input", "patch", "command"]);
+    if (!patch)
+        return [];
+    return parseApplyPatchRequests(patch, event.toolName);
+}
+export function parseApplyPatchRequests(patch, sourceToolName = "apply_patch") {
+    const requests = [];
+    let current;
+    const flush = () => {
+        if (!current)
+            return;
+        if (current.operation === "add") {
+            const content = joinPatchLines(current.newLines);
+            if (content.length > 0) {
+                requests.push({
+                    sourceToolName,
+                    toolName: "Write",
+                    filePath: current.filePath,
+                    toolInput: {
+                        file_path: current.filePath,
+                        content,
+                    },
+                });
+            }
+        }
+        if (current.operation === "update") {
+            const newString = joinPatchLines(current.newLines);
+            if (newString.length > 0) {
+                const filePath = current.movePath ?? current.filePath;
+                requests.push({
+                    sourceToolName,
+                    toolName: "Edit",
+                    filePath,
+                    toolInput: {
+                        file_path: filePath,
+                        old_string: joinPatchLines(current.oldLines),
+                        new_string: newString,
+                    },
+                });
+            }
+        }
+        current = undefined;
+    };
+    for (const line of patch.split(/\r?\n/)) {
+        if (line === "*** Begin Patch" || line === "*** End Patch")
+            continue;
+        if (line.startsWith("*** Add File: ")) {
+            flush();
+            current = makeAccumulator("add", line.slice("*** Add File: ".length).trim());
+            continue;
+        }
+        if (line.startsWith("*** Update File: ")) {
+            flush();
+            current = makeAccumulator("update", line.slice("*** Update File: ".length).trim());
+            continue;
+        }
+        if (line.startsWith("*** Delete File: ")) {
+            flush();
+            current = makeAccumulator("delete", line.slice("*** Delete File: ".length).trim());
+            continue;
+        }
+        if (line.startsWith("*** Move to: ")) {
+            if (current?.operation === "update")
+                current.movePath = line.slice("*** Move to: ".length).trim();
+            continue;
+        }
+        if (!current)
+            continue;
+        if (line.startsWith("@@"))
+            continue;
+        if (current.operation === "add") {
+            if (line.startsWith("+"))
+                current.newLines.push(line.slice(1));
+            continue;
+        }
+        if (current.operation === "update") {
+            if (line.startsWith("+"))
+                current.newLines.push(line.slice(1));
+            if (line.startsWith("-"))
+                current.oldLines.push(line.slice(1));
+        }
+    }
+    flush();
+    return requests;
+}
+function extractApplyPatchMetadataRequests(details, sourceToolName) {
+    const metadataFiles = getApplyPatchMetadataFiles(details);
+    if (metadataFiles.length === 0)
+        return [];
+    const requests = [];
+    for (const file of metadataFiles) {
+        if (file.type === "delete")
+            continue;
+        const filePath = file.movePath ?? file.filePath;
+        if (file.before.length === 0) {
+            requests.push({
+                sourceToolName,
+                toolName: "Write",
+                filePath,
+                toolInput: {
+                    file_path: filePath,
+                    content: file.after,
+                },
+            });
+            continue;
+        }
+        requests.push({
+            sourceToolName,
+            toolName: "Edit",
+            filePath,
+            toolInput: {
+                file_path: filePath,
+                old_string: file.before,
+                new_string: file.after,
+            },
+        });
+    }
+    return requests;
+}
+function getApplyPatchMetadataFiles(details) {
+    if (!isRecord(details))
+        return [];
+    const direct = readApplyPatchMetadataFiles(details["files"]);
+    if (direct.length > 0)
+        return direct;
+    const resultDetails = details["result"];
+    const result = isRecord(resultDetails) ? readApplyPatchMetadataFiles(resultDetails["files"]) : [];
+    if (result.length > 0)
+        return result;
+    const metadataDetails = details["metadata"];
+    const metadata = isRecord(metadataDetails) ? readApplyPatchMetadataFiles(metadataDetails["files"]) : [];
+    return metadata;
+}
+function readApplyPatchMetadataFiles(value) {
+    if (!Array.isArray(value))
+        return [];
+    const files = [];
+    for (const item of value) {
+        if (!isRecord(item))
+            continue;
+        const filePath = getString(item, ["filePath", "file_path", "path"]);
+        const movePath = getString(item, ["movePath", "move_path"]);
+        const before = getString(item, ["before", "old", "oldString", "old_string"]);
+        const after = getString(item, ["after", "new", "newString", "new_string"]);
+        const type = getString(item, ["type", "operation"]);
+        if (!filePath || before === undefined || after === undefined)
+            continue;
+        files.push({
+            filePath,
+            before,
+            after,
+            ...(movePath === undefined ? {} : { movePath }),
+            ...(type === undefined ? {} : { type }),
+        });
+    }
+    return files;
+}
+function makeAccumulator(operation, filePath) {
+    return {
+        operation,
+        filePath,
+        oldLines: [],
+        newLines: [],
+    };
+}
+function joinPatchLines(lines) {
+    return lines.length === 0 ? "" : `${lines.join("\n")}\n`;
+}

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

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

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

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+import { runCodexHookCli } from "./codex-hook.js";
+const [command, subcommand] = process.argv.slice(2);
+if (command === "hook" && subcommand === "post-tool-use") {
+    await runCodexHookCli();
+}
+else {
+    process.stderr.write("Usage: omo-comment-checker hook post-tool-use\n");
+    process.exitCode = 2;
+}

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

@@ -0,0 +1,22 @@
+import { type CommentCheckRequest } from "./core.js";
+import { type CommentCheckerRunner } from "./runner.js";
+export type CodexPostToolUseInput = {
+    session_id: string;
+    turn_id: string;
+    transcript_path: string | null;
+    cwd: string;
+    hook_event_name: "PostToolUse";
+    model: string;
+    permission_mode: string;
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_response: unknown;
+    tool_use_id: string;
+};
+export type CodexHookOptions = {
+    run?: CommentCheckerRunner;
+};
+export declare function extractCodexCommentCheckRequests(input: CodexPostToolUseInput): CommentCheckRequest[];
+export declare function runCommentCheckerPostToolUse(input: CodexPostToolUseInput, options?: CodexHookOptions): Promise<string>;
+export declare function runCodexHookCli(): Promise<void>;
+export declare function parseCodexPostToolUseInput(input: string): CodexPostToolUseInput | undefined;