oh-my-opencode 4.10.0 → 4.11.0

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

@@ -1,8 +0,0 @@
-import { basename, extname } from "node:path";
-const BASENAME_EXTENSIONS = {
-    Dockerfile: ".dockerfile",
-    Containerfile: ".dockerfile",
-};
-export function effectiveExtension(filePath) {
-    return BASENAME_EXTENSIONS[basename(filePath)] ?? extname(filePath);
-}

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

@@ -1,56 +0,0 @@
-export class LspConnectionClosedError extends Error {
-    constructor(serverId, root, message) {
-        super(message ?? `LSP connection closed for ${serverId} at ${root}`);
-        this.serverId = serverId;
-        this.root = root;
-        this.name = "LspConnectionClosedError";
-    }
-}
-export class LspProcessExitedError extends Error {
-    constructor(serverId, root, exitCode, stderrTail) {
-        const stderrSuffix = stderrTail ? `\nstderr tail: ${stderrTail}` : "";
-        super(`LSP server ${serverId} at ${root} exited with code ${exitCode ?? "null"}${stderrSuffix}`);
-        this.serverId = serverId;
-        this.root = root;
-        this.exitCode = exitCode;
-        this.stderrTail = stderrTail;
-        this.name = "LspProcessExitedError";
-    }
-}
-export class LspRequestTimeoutError extends Error {
-    constructor(method, stderrTail) {
-        const stderrSuffix = stderrTail ? `\nrecent stderr: ${stderrTail}` : "";
-        super(`LSP request timeout (method: ${method})${stderrSuffix}`);
-        this.method = method;
-        this.stderrTail = stderrTail;
-        this.name = "LspRequestTimeoutError";
-    }
-}
-export class LspInvalidPathError extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = "LspInvalidPathError";
-    }
-}
-export class LspServerLookupError extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = "LspServerLookupError";
-    }
-}
-export class LspServerInitializingError extends Error {
-    constructor(originalError) {
-        super(`LSP server is still initializing. Please retry in a few seconds. Original error: ${originalError.message}`);
-        this.originalError = originalError;
-        this.name = "LspServerInitializingError";
-    }
-}
-export class LspProcessSpawnError extends Error {
-    constructor() {
-        super(...arguments);
-        this.name = "LspProcessSpawnError";
-    }
-}
-export function isLspDeadConnectionError(err) {
-    return err instanceof LspConnectionClosedError || err instanceof LspProcessExitedError;
-}

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

@@ -1,106 +0,0 @@
-import { fileURLToPath } from "node:url";
-import { SEVERITY_MAP, SYMBOL_KIND_MAP } from "./language-mappings.js";
-const DIAGNOSTIC_SEVERITY_FILTERS = {
-    error: 1,
-    warning: 2,
-    information: 3,
-    hint: 4,
-};
-export function uriToPath(uri) {
-    return fileURLToPath(uri);
-}
-export function formatLocation(loc) {
-    if ("targetUri" in loc) {
-        const uri = uriToPath(loc.targetUri);
-        const line = loc.targetRange.start.line + 1;
-        const char = loc.targetRange.start.character;
-        return `${uri}:${line}:${char}`;
-    }
-    const uri = uriToPath(loc.uri);
-    const line = loc.range.start.line + 1;
-    const char = loc.range.start.character;
-    return `${uri}:${line}:${char}`;
-}
-export function formatSymbolKind(kind) {
-    return SYMBOL_KIND_MAP[kind] ?? `Unknown(${kind})`;
-}
-export function formatSeverity(severity) {
-    if (!severity)
-        return "unknown";
-    return SEVERITY_MAP[severity] ?? `unknown(${severity})`;
-}
-export function formatDocumentSymbol(symbol, indent = 0) {
-    const prefix = "  ".repeat(indent);
-    const kind = formatSymbolKind(symbol.kind);
-    const line = symbol.range.start.line + 1;
-    let result = `${prefix}${symbol.name} (${kind}) - line ${line}`;
-    if (symbol.children && symbol.children.length > 0) {
-        for (const child of symbol.children) {
-            result += `\n${formatDocumentSymbol(child, indent + 1)}`;
-        }
-    }
-    return result;
-}
-export function formatSymbolInfo(symbol) {
-    const kind = formatSymbolKind(symbol.kind);
-    const loc = formatLocation(symbol.location);
-    const container = symbol.containerName ? ` (in ${symbol.containerName})` : "";
-    return `${symbol.name} (${kind})${container} - ${loc}`;
-}
-export function formatDiagnostic(diag) {
-    const severity = formatSeverity(diag.severity);
-    const line = diag.range.start.line + 1;
-    const char = diag.range.start.character;
-    const source = diag.source ? `[${diag.source}]` : "";
-    const code = diag.code ? ` (${diag.code})` : "";
-    return `${severity}${source}${code} at ${line}:${char}: ${diag.message}`;
-}
-export function filterDiagnosticsBySeverity(diagnostics, severityFilter) {
-    if (!severityFilter || severityFilter === "all") {
-        return diagnostics;
-    }
-    const targetSeverity = DIAGNOSTIC_SEVERITY_FILTERS[severityFilter];
-    return diagnostics.filter((d) => d.severity === targetSeverity);
-}
-export function formatPrepareRenameResult(result) {
-    if (!result)
-        return "Cannot rename at this position";
-    if ("defaultBehavior" in result) {
-        return result.defaultBehavior ? "Rename supported (using default behavior)" : "Cannot rename at this position";
-    }
-    if ("range" in result && result.range) {
-        const startLine = result.range.start.line + 1;
-        const startChar = result.range.start.character;
-        const endLine = result.range.end.line + 1;
-        const endChar = result.range.end.character;
-        const placeholder = result.placeholder ? ` (current: "${result.placeholder}")` : "";
-        return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}${placeholder}`;
-    }
-    if ("start" in result && "end" in result) {
-        const startLine = result.start.line + 1;
-        const startChar = result.start.character;
-        const endLine = result.end.line + 1;
-        const endChar = result.end.character;
-        return `Rename available at ${startLine}:${startChar}-${endLine}:${endChar}`;
-    }
-    return "Cannot rename at this position";
-}
-export function formatApplyResult(result) {
-    const lines = [];
-    if (result.success) {
-        lines.push(`Applied ${result.totalEdits} edit(s) to ${result.filesModified.length} file(s):`);
-        for (const file of result.filesModified) {
-            lines.push(`  - ${file}`);
-        }
-    }
-    else {
-        lines.push("Failed to apply some changes:");
-        for (const err of result.errors) {
-            lines.push(`  Error: ${err}`);
-        }
-        if (result.filesModified.length > 0) {
-            lines.push(`Successfully modified: ${result.filesModified.join(", ")}`);
-        }
-    }
-    return lines.join("\n");
-}

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

@@ -1,59 +0,0 @@
-import { lstatSync, readdirSync } from "node:fs";
-import { join } from "node:path";
-import { effectiveExtension } from "./effective-extension.js";
-import { EXT_TO_LANG } from "./language-mappings.js";
-const SKIP_DIRECTORIES = new Set(["node_modules", ".git", "dist", "build", ".next", "out"]);
-const MAX_SCAN_ENTRIES = 500;
-export function inferExtensionFromDirectory(directory) {
-    const extensionCounts = new Map();
-    let scanned = 0;
-    function walk(dir) {
-        if (scanned >= MAX_SCAN_ENTRIES)
-            return;
-        let entries;
-        try {
-            entries = readdirSync(dir);
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (scanned >= MAX_SCAN_ENTRIES)
-                return;
-            const fullPath = join(dir, entry);
-            let stat;
-            try {
-                stat = lstatSync(fullPath);
-            }
-            catch {
-                continue;
-            }
-            if (stat.isSymbolicLink())
-                continue;
-            scanned++;
-            if (stat.isDirectory()) {
-                if (!SKIP_DIRECTORIES.has(entry)) {
-                    walk(fullPath);
-                }
-            }
-            else if (stat.isFile()) {
-                const ext = effectiveExtension(fullPath);
-                if (ext && ext in EXT_TO_LANG) {
-                    extensionCounts.set(ext, (extensionCounts.get(ext) ?? 0) + 1);
-                }
-            }
-        }
-    }
-    walk(directory);
-    if (extensionCounts.size === 0)
-        return null;
-    let maxExt = "";
-    let maxCount = 0;
-    for (const [ext, count] of extensionCounts) {
-        if (count > maxCount) {
-            maxCount = count;
-            maxExt = ext;
-        }
-    }
-    return maxExt || null;
-}

package/packages/lsp-tools-mcp/dist/lsp/json-rpc-connection.js

@@ -1,247 +0,0 @@
-const HEADER_SEPARATOR = "\r\n\r\n";
-const PARSE_ERROR = -32700;
-const INVALID_REQUEST = -32600;
-const METHOD_NOT_FOUND = -32601;
-const INTERNAL_ERROR = -32603;
-export class JsonRpcConnection {
-    constructor(reader, writer) {
-        this.reader = reader;
-        this.writer = writer;
-        this.pendingRequests = new Map();
-        this.notificationHandlers = new Map();
-        this.requestHandlers = new Map();
-        this.closeHandlers = [];
-        this.errorHandlers = [];
-        this.inputBuffer = Buffer.alloc(0);
-        this.nextRequestId = 1;
-        this.listening = false;
-        this.disposed = false;
-        this.handleData = (chunk) => {
-            const chunkBuffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, "utf8");
-            this.inputBuffer = Buffer.concat([this.inputBuffer, chunkBuffer]);
-            this.drainInputBuffer();
-        };
-        this.handleClose = () => {
-            for (const handler of this.closeHandlers) {
-                handler();
-            }
-        };
-        this.handleStreamError = (error) => {
-            this.emitError(error);
-        };
-    }
-    listen() {
-        if (this.listening)
-            return;
-        this.listening = true;
-        this.reader.on("data", this.handleData);
-        this.reader.on("close", this.handleClose);
-        this.reader.on("end", this.handleClose);
-        this.reader.on("error", this.handleStreamError);
-        this.writer.on("error", this.handleStreamError);
-    }
-    onNotification(method, handler) {
-        this.notificationHandlers.set(method, handler);
-    }
-    onRequest(method, handler) {
-        this.requestHandlers.set(method, handler);
-    }
-    onClose(handler) {
-        this.closeHandlers.push(handler);
-    }
-    onError(handler) {
-        this.errorHandlers.push(handler);
-    }
-    async sendRequest(method, params) {
-        if (this.disposed)
-            throw new Error("JSON-RPC connection is disposed");
-        const id = this.nextRequestId;
-        this.nextRequestId += 1;
-        const message = params === undefined ? { jsonrpc: "2.0", id, method } : { jsonrpc: "2.0", id, method, params };
-        const responsePromise = new Promise((resolve, reject) => {
-            this.pendingRequests.set(String(id), {
-                resolve(result) {
-                    resolve(result);
-                },
-                reject,
-            });
-        });
-        try {
-            await this.writeMessage(message);
-        }
-        catch (error) {
-            this.pendingRequests.delete(String(id));
-            throw error;
-        }
-        return responsePromise;
-    }
-    async sendNotification(method, params) {
-        if (this.disposed)
-            return;
-        const message = params === undefined ? { jsonrpc: "2.0", method } : { jsonrpc: "2.0", method, params };
-        await this.writeMessage(message);
-    }
-    dispose() {
-        if (this.disposed)
-            return;
-        this.disposed = true;
-        this.reader.off("data", this.handleData);
-        this.reader.off("close", this.handleClose);
-        this.reader.off("end", this.handleClose);
-        this.reader.off("error", this.handleStreamError);
-        this.writer.off("error", this.handleStreamError);
-        for (const pending of this.pendingRequests.values()) {
-            pending.reject(new Error("JSON-RPC connection disposed"));
-        }
-        this.pendingRequests.clear();
-        this.notificationHandlers.clear();
-        this.requestHandlers.clear();
-    }
-    drainInputBuffer() {
-        while (true) {
-            const headerEnd = this.inputBuffer.indexOf(HEADER_SEPARATOR);
-            if (headerEnd === -1)
-                return;
-            const headers = this.inputBuffer.subarray(0, headerEnd).toString("ascii");
-            const contentLength = parseContentLength(headers);
-            if (contentLength === null) {
-                this.inputBuffer = Buffer.alloc(0);
-                this.emitError(new Error("JSON-RPC message is missing Content-Length header"));
-                return;
-            }
-            const bodyStart = headerEnd + Buffer.byteLength(HEADER_SEPARATOR);
-            const bodyEnd = bodyStart + contentLength;
-            if (this.inputBuffer.length < bodyEnd)
-                return;
-            const body = this.inputBuffer.subarray(bodyStart, bodyEnd).toString("utf8");
-            this.inputBuffer = this.inputBuffer.subarray(bodyEnd);
-            this.dispatchBody(body);
-        }
-    }
-    dispatchBody(body) {
-        let parsed;
-        try {
-            parsed = JSON.parse(body);
-        }
-        catch (error) {
-            void this.writeError(null, PARSE_ERROR, error instanceof Error ? error.message : "Parse error").catch((writeError) => this.emitError(toError(writeError)));
-            return;
-        }
-        if (!isJsonRpcObject(parsed)) {
-            void this.writeError(null, INVALID_REQUEST, "Invalid JSON-RPC message").catch((error) => this.emitError(toError(error)));
-            return;
-        }
-        if ("id" in parsed && ("result" in parsed || "error" in parsed)) {
-            this.handleResponse(parsed);
-            return;
-        }
-        if (typeof parsed["method"] !== "string") {
-            const id = getMessageId(parsed) ?? null;
-            void this.writeError(id, INVALID_REQUEST, "Invalid JSON-RPC method").catch((error) => this.emitError(toError(error)));
-            return;
-        }
-        if ("id" in parsed) {
-            this.handleRequest(parsed);
-            return;
-        }
-        this.handleNotification(parsed["method"], parsed["params"]);
-    }
-    handleResponse(message) {
-        const id = getMessageId(message);
-        if (id === undefined)
-            return;
-        const pending = this.pendingRequests.get(String(id));
-        if (!pending)
-            return;
-        this.pendingRequests.delete(String(id));
-        if ("error" in message) {
-            pending.reject(jsonRpcErrorToError(message["error"]));
-            return;
-        }
-        pending.resolve(message["result"]);
-    }
-    handleNotification(method, params) {
-        const handler = this.notificationHandlers.get(method);
-        if (!handler)
-            return;
-        try {
-            handler(params);
-        }
-        catch (error) {
-            this.emitError(toError(error));
-        }
-    }
-    handleRequest(message) {
-        const id = getMessageId(message);
-        if (id === undefined) {
-            void this.writeError(null, INVALID_REQUEST, "Invalid JSON-RPC id").catch((error) => this.emitError(toError(error)));
-            return;
-        }
-        const method = typeof message["method"] === "string" ? message["method"] : "";
-        const handler = this.requestHandlers.get(method);
-        if (!handler) {
-            void this.writeError(id, METHOD_NOT_FOUND, `Method not found: ${method}`).catch((error) => this.emitError(toError(error)));
-            return;
-        }
-        Promise.resolve()
-            .then(() => handler(message["params"]))
-            .then((result) => this.writeMessage({ jsonrpc: "2.0", id, result }), (error) => this.writeError(id, INTERNAL_ERROR, toError(error).message))
-            .catch((error) => this.emitError(toError(error)));
-    }
-    async writeError(id, code, message) {
-        await this.writeMessage({ jsonrpc: "2.0", id, error: { code, message } });
-    }
-    writeMessage(message) {
-        const body = JSON.stringify(message);
-        const payload = `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
-        return new Promise((resolve, reject) => {
-            this.writer.write(payload, (error) => {
-                if (error) {
-                    reject(error);
-                    return;
-                }
-                resolve();
-            });
-        });
-    }
-    emitError(error) {
-        for (const handler of this.errorHandlers) {
-            handler(error);
-        }
-    }
-}
-function parseContentLength(headers) {
-    for (const line of headers.split("\r\n")) {
-        const separatorIndex = line.indexOf(":");
-        if (separatorIndex === -1)
-            continue;
-        const name = line.slice(0, separatorIndex).trim().toLowerCase();
-        if (name !== "content-length")
-            continue;
-        const value = Number.parseInt(line.slice(separatorIndex + 1).trim(), 10);
-        return Number.isFinite(value) && value >= 0 ? value : null;
-    }
-    return null;
-}
-function isJsonRpcObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function getMessageId(message) {
-    const id = message["id"];
-    if (typeof id === "number" || typeof id === "string" || id === null)
-        return id;
-    return undefined;
-}
-function jsonRpcErrorToError(value) {
-    if (!isJsonRpcObject(value))
-        return new Error("JSON-RPC request failed");
-    const message = typeof value["message"] === "string" ? value["message"] : "JSON-RPC request failed";
-    const error = new Error(message);
-    if (typeof value["code"] === "number") {
-        error.name = `JsonRpcError(${value["code"]})`;
-    }
-    return error;
-}
-function toError(error) {
-    return error instanceof Error ? error : new Error(String(error));
-}

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

@@ -1,170 +0,0 @@
-export const SYMBOL_KIND_MAP = {
-    1: "File",
-    2: "Module",
-    3: "Namespace",
-    4: "Package",
-    5: "Class",
-    6: "Method",
-    7: "Property",
-    8: "Field",
-    9: "Constructor",
-    10: "Enum",
-    11: "Interface",
-    12: "Function",
-    13: "Variable",
-    14: "Constant",
-    15: "String",
-    16: "Number",
-    17: "Boolean",
-    18: "Array",
-    19: "Object",
-    20: "Key",
-    21: "Null",
-    22: "EnumMember",
-    23: "Struct",
-    24: "Event",
-    25: "Operator",
-    26: "TypeParameter",
-};
-export const SEVERITY_MAP = {
-    1: "error",
-    2: "warning",
-    3: "information",
-    4: "hint",
-};
-export const EXT_TO_LANG = {
-    ".abap": "abap",
-    ".bat": "bat",
-    ".bib": "bibtex",
-    ".bibtex": "bibtex",
-    ".clj": "clojure",
-    ".cljs": "clojure",
-    ".cljc": "clojure",
-    ".edn": "clojure",
-    ".coffee": "coffeescript",
-    ".c": "c",
-    ".cpp": "cpp",
-    ".cxx": "cpp",
-    ".cc": "cpp",
-    ".c++": "cpp",
-    ".cs": "csharp",
-    ".css": "css",
-    ".d": "d",
-    ".pas": "pascal",
-    ".pascal": "pascal",
-    ".diff": "diff",
-    ".patch": "diff",
-    ".dart": "dart",
-    ".dockerfile": "dockerfile",
-    ".ex": "elixir",
-    ".exs": "elixir",
-    ".erl": "erlang",
-    ".hrl": "erlang",
-    ".fs": "fsharp",
-    ".fsi": "fsharp",
-    ".fsx": "fsharp",
-    ".fsscript": "fsharp",
-    ".gitcommit": "git-commit",
-    ".gitrebase": "git-rebase",
-    ".go": "go",
-    ".groovy": "groovy",
-    ".gleam": "gleam",
-    ".hbs": "handlebars",
-    ".handlebars": "handlebars",
-    ".hs": "haskell",
-    ".html": "html",
-    ".htm": "html",
-    ".ini": "ini",
-    ".java": "java",
-    ".jl": "julia",
-    ".js": "javascript",
-    ".jsx": "javascriptreact",
-    ".json": "json",
-    ".jsonc": "jsonc",
-    ".tex": "latex",
-    ".latex": "latex",
-    ".less": "less",
-    ".lua": "lua",
-    ".makefile": "makefile",
-    makefile: "makefile",
-    ".md": "markdown",
-    ".markdown": "markdown",
-    ".m": "objective-c",
-    ".mm": "objective-cpp",
-    ".pl": "perl",
-    ".pm": "perl",
-    ".pm6": "perl6",
-    ".php": "php",
-    ".ps1": "powershell",
-    ".psm1": "powershell",
-    ".pug": "jade",
-    ".jade": "jade",
-    ".py": "python",
-    ".pyi": "python",
-    ".r": "r",
-    ".cshtml": "razor",
-    ".razor": "razor",
-    ".rb": "ruby",
-    ".rake": "ruby",
-    ".gemspec": "ruby",
-    ".ru": "ruby",
-    ".erb": "erb",
-    ".html.erb": "erb",
-    ".js.erb": "erb",
-    ".css.erb": "erb",
-    ".json.erb": "erb",
-    ".rs": "rust",
-    ".scss": "scss",
-    ".sass": "sass",
-    ".scala": "scala",
-    ".shader": "shaderlab",
-    ".sh": "shellscript",
-    ".bash": "shellscript",
-    ".zsh": "shellscript",
-    ".ksh": "shellscript",
-    ".sql": "sql",
-    ".svelte": "svelte",
-    ".swift": "swift",
-    ".ts": "typescript",
-    ".tsx": "typescriptreact",
-    ".mts": "typescript",
-    ".cts": "typescript",
-    ".mtsx": "typescriptreact",
-    ".ctsx": "typescriptreact",
-    ".xml": "xml",
-    ".xsl": "xsl",
-    ".yaml": "yaml",
-    ".yml": "yaml",
-    ".mjs": "javascript",
-    ".cjs": "javascript",
-    ".vue": "vue",
-    ".zig": "zig",
-    ".zon": "zig",
-    ".astro": "astro",
-    ".ml": "ocaml",
-    ".mli": "ocaml",
-    ".tf": "terraform",
-    ".tfvars": "terraform-vars",
-    ".hcl": "hcl",
-    ".nix": "nix",
-    ".typ": "typst",
-    ".typc": "typst",
-    ".ets": "typescript",
-    ".lhs": "haskell",
-    ".kt": "kotlin",
-    ".kts": "kotlin",
-    ".prisma": "prisma",
-    ".h": "c",
-    ".hpp": "cpp",
-    ".hh": "cpp",
-    ".hxx": "cpp",
-    ".h++": "cpp",
-    ".objc": "objective-c",
-    ".objcpp": "objective-cpp",
-    ".fish": "fish",
-    ".graphql": "graphql",
-    ".gql": "graphql",
-};
-export function getLanguageId(ext) {
-    return EXT_TO_LANG[ext] ?? "plaintext";
-}

package/packages/lsp-tools-mcp/dist/lsp/process-signal-cleanup.js

@@ -1,17 +0,0 @@
-import { reportBestEffortCleanupError } from "./cleanup-errors.js";
-export function installProcessSignalCleanup(cleanup) {
-    const signals = process.platform === "win32" ? ["SIGINT", "SIGTERM", "SIGBREAK"] : ["SIGINT", "SIGTERM"];
-    const handler = () => {
-        void cleanup().catch((error) => {
-            reportBestEffortCleanupError("signal cleanup", error);
-        });
-    };
-    for (const signal of signals) {
-        process.on(signal, handler);
-    }
-    return () => {
-        for (const signal of signals) {
-            process.removeListener(signal, handler);
-        }
-    };
-}