oh-my-opencode 4.8.0 → 4.9.0

package/packages/lsp-daemon/dist/lock.d.ts

@@ -0,0 +1,7 @@
+export interface LockHandle {
+    release(): void;
+}
+export declare function isProcessAlive(pid: number): boolean;
+export declare function readLockPid(lockPath: string): number | null;
+export declare function tryAcquireLock(lockPath: string, ownerPid?: number): LockHandle | null;
+export declare function unlinkQuietly(path: string): void;

package/packages/lsp-daemon/dist/lock.js

@@ -0,0 +1,61 @@
+import { closeSync, mkdirSync, openSync, readFileSync, unlinkSync, writeSync } from "node:fs";
+import { dirname } from "node:path";
+export function isProcessAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0)
+        return false;
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === "EPERM";
+    }
+}
+export function readLockPid(lockPath) {
+    try {
+        const pid = Number.parseInt(readFileSync(lockPath, "utf8").trim(), 10);
+        return Number.isInteger(pid) ? pid : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function tryAcquireLock(lockPath, ownerPid = process.pid) {
+    mkdirSync(dirname(lockPath), { recursive: true });
+    for (let attempt = 0; attempt < 2; attempt += 1) {
+        const handle = writeLockFile(lockPath, ownerPid);
+        if (handle)
+            return handle;
+        if (!reapStaleLock(lockPath))
+            return null;
+    }
+    return null;
+}
+function writeLockFile(lockPath, ownerPid) {
+    try {
+        const fd = openSync(lockPath, "wx");
+        writeSync(fd, `${ownerPid}\n`);
+        closeSync(fd);
+        return { release: () => unlinkQuietly(lockPath) };
+    }
+    catch (error) {
+        if (error.code === "EEXIST")
+            return null;
+        throw error;
+    }
+}
+function reapStaleLock(lockPath) {
+    const pid = readLockPid(lockPath);
+    if (pid !== null && isProcessAlive(pid))
+        return false;
+    unlinkQuietly(lockPath);
+    return true;
+}
+export function unlinkQuietly(path) {
+    try {
+        unlinkSync(path);
+    }
+    catch (error) {
+        void error;
+    }
+}

package/packages/lsp-daemon/dist/package.json

@@ -0,0 +1,6 @@
+{
+	"name": "@code-yeongyu/lsp-daemon",
+	"version": "0.1.0",
+	"type": "module",
+	"private": true
+}

package/packages/lsp-daemon/dist/paths.d.ts

@@ -0,0 +1,11 @@
+export interface DaemonPaths {
+    version: string;
+    dir: string;
+    socket: string;
+    lock: string;
+    pid: string;
+    log: string;
+}
+export declare function resolveDaemonVersion(requireFn?: (id: string) => unknown): string;
+export declare function daemonBaseDir(env?: NodeJS.ProcessEnv): string;
+export declare function daemonPaths(env?: NodeJS.ProcessEnv, version?: string): DaemonPaths;

package/packages/lsp-daemon/dist/paths.js

@@ -0,0 +1,49 @@
+import { createHash } from "node:crypto";
+import { createRequire } from "node:module";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+const requireFromHere = createRequire(import.meta.url);
+const MAX_SOCKET_PATH_LENGTH = 100;
+export function resolveDaemonVersion(requireFn = requireFromHere) {
+    for (const candidate of ["./package.json", "../package.json"]) {
+        try {
+            const pkg = requireFn(candidate);
+            if (typeof pkg.version === "string" && pkg.version.length > 0)
+                return pkg.version;
+        }
+        catch { }
+    }
+    return "0";
+}
+export function daemonBaseDir(env = process.env) {
+    const explicit = env["CODEX_LSP_DAEMON_DIR"]?.trim();
+    if (explicit)
+        return explicit;
+    const pluginData = env["PLUGIN_DATA"]?.trim();
+    if (pluginData)
+        return join(pluginData, "daemon");
+    const codexHome = env["CODEX_HOME"]?.trim();
+    const home = codexHome && codexHome.length > 0 ? codexHome : join(homedir(), ".codex");
+    return join(home, "codex-lsp", "daemon");
+}
+export function daemonPaths(env = process.env, version = resolveDaemonVersion()) {
+    const dir = join(daemonBaseDir(env), `v${version}`);
+    return {
+        version,
+        dir,
+        socket: resolveSocketPath(dir, version),
+        lock: join(dir, "daemon.lock"),
+        pid: join(dir, "daemon.pid"),
+        log: join(dir, "daemon.log"),
+    };
+}
+function resolveSocketPath(dir, version) {
+    const digest = createHash("sha256").update(dir).digest("hex").slice(0, 16);
+    if (process.platform === "win32") {
+        return `\\\\.\\pipe\\omo-lsp-${version}-${digest}`;
+    }
+    const natural = join(dir, "daemon.sock");
+    if (natural.length < MAX_SOCKET_PATH_LENGTH)
+        return natural;
+    return join(tmpdir(), `omo-lsp-${version}-${digest}.sock`);
+}

package/packages/lsp-daemon/dist/proxy.d.ts

@@ -0,0 +1,10 @@
+import { type CallToolOptions, type DaemonToolContext } from "./daemon-client.js";
+import { type DaemonPaths } from "./paths.js";
+export interface ProxyOptions {
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+    paths?: DaemonPaths;
+    context?: DaemonToolContext;
+    ensure?: CallToolOptions["ensure"];
+}
+export declare function runMcpStdioProxy(options?: ProxyOptions): Promise<void>;

package/packages/lsp-daemon/dist/proxy.js

@@ -0,0 +1,61 @@
+import { createInterface } from "node:readline";
+import { handleLspMcpRequest } from "@code-yeongyu/lsp-tools-mcp/dist/mcp.js";
+import { callToolViaDaemon, currentRequestContext, } from "./daemon-client.js";
+import { daemonPaths } from "./paths.js";
+export async function runMcpStdioProxy(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const paths = options.paths ?? daemonPaths();
+    const context = options.context ?? currentRequestContext();
+    const callOptions = { paths, context, ...(options.ensure ? { ensure: options.ensure } : {}) };
+    const lines = createInterface({ input, crlfDelay: Number.POSITIVE_INFINITY });
+    for await (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const response = await handleLine(line, callOptions);
+            if (response)
+                output.write(`${JSON.stringify(response)}\n`);
+        }
+        catch (error) {
+            process.stderr.write(`[lsp-daemon] proxy error: ${error instanceof Error ? error.message : String(error)}\n`);
+        }
+    }
+}
+async function handleLine(line, callOptions) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        return parseErrorResponse(error);
+    }
+    const toolCall = asToolCall(parsed);
+    if (!toolCall)
+        return handleLspMcpRequest(parsed);
+    const result = await callToolViaDaemon(toolCall.name, toolCall.args, callOptions);
+    return {
+        jsonrpc: "2.0",
+        id: toolCall.id,
+        result: { content: result.content, isError: result.isError ?? false, details: result.details },
+    };
+}
+function asToolCall(parsed) {
+    if (!isRecord(parsed) || parsed["method"] !== "tools/call")
+        return null;
+    const params = parsed["params"];
+    if (!isRecord(params) || typeof params["name"] !== "string")
+        return null;
+    const args = params["arguments"];
+    return { id: jsonRpcId(parsed["id"]), name: params["name"], args: isRecord(args) ? args : {} };
+}
+function jsonRpcId(value) {
+    return typeof value === "string" || typeof value === "number" || value === null ? value : null;
+}
+function parseErrorResponse(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error", data: message } };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/packages/lsp-daemon/dist/request-routing.d.ts

@@ -0,0 +1,9 @@
+import { type JsonRpcResponse } from "@code-yeongyu/lsp-tools-mcp/dist/mcp.js";
+import { type RequestContext } from "@code-yeongyu/lsp-tools-mcp/dist/request-context.js";
+export declare const CONTEXT_KEY = "_context";
+export interface RoutedRequest {
+    input: unknown;
+    context: RequestContext | undefined;
+}
+export declare function extractRequestContext(raw: unknown): RoutedRequest;
+export declare function handleDaemonMessage(raw: unknown): Promise<JsonRpcResponse | undefined>;

package/packages/lsp-daemon/dist/request-routing.js

@@ -0,0 +1,44 @@
+import { handleLspMcpRequest } from "@code-yeongyu/lsp-tools-mcp/dist/mcp.js";
+import { runWithRequestContext } from "@code-yeongyu/lsp-tools-mcp/dist/request-context.js";
+export const CONTEXT_KEY = "_context";
+export function extractRequestContext(raw) {
+    if (!isRecord(raw) || raw["method"] !== "tools/call")
+        return { input: raw, context: undefined };
+    const params = raw["params"];
+    if (!isRecord(params))
+        return { input: raw, context: undefined };
+    const args = params["arguments"];
+    if (!isRecord(args))
+        return { input: raw, context: undefined };
+    const context = parseContext(args[CONTEXT_KEY]);
+    if (!context)
+        return { input: raw, context: undefined };
+    const cleanedArgs = { ...args };
+    delete cleanedArgs[CONTEXT_KEY];
+    const cleaned = { ...raw, params: { ...params, arguments: cleanedArgs } };
+    return { input: cleaned, context };
+}
+export function handleDaemonMessage(raw) {
+    const { input, context } = extractRequestContext(raw);
+    if (context)
+        return runWithRequestContext(context, () => handleLspMcpRequest(input));
+    return handleLspMcpRequest(input);
+}
+function parseContext(value) {
+    if (!isRecord(value))
+        return undefined;
+    const context = {};
+    const cwd = value["cwd"];
+    if (typeof cwd === "string")
+        context.cwd = cwd;
+    const env = value["env"];
+    if (isStringRecord(env))
+        context.env = env;
+    return context.cwd === undefined && context.env === undefined ? undefined : context;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStringRecord(value) {
+    return isRecord(value) && Object.values(value).every((item) => typeof item === "string");
+}

package/packages/lsp-daemon/dist/run-daemon.d.ts

@@ -0,0 +1 @@
+export declare function runDaemon(): Promise<void>;

package/packages/lsp-daemon/dist/run-daemon.js

@@ -0,0 +1,11 @@
+import { startDaemonServer } from "./daemon-server.js";
+import { daemonPaths } from "./paths.js";
+export async function runDaemon() {
+    process.on("uncaughtException", (error) => logNonFatal("uncaughtException", error));
+    process.on("unhandledRejection", (reason) => logNonFatal("unhandledRejection", reason));
+    await startDaemonServer(daemonPaths());
+}
+function logNonFatal(kind, error) {
+    const message = error instanceof Error ? (error.stack ?? error.message) : String(error);
+    process.stderr.write(`[lsp-daemon] ${kind}: ${message}\n`);
+}

package/packages/lsp-daemon/dist/socket-jsonrpc.d.ts

@@ -0,0 +1,5 @@
+export declare function encodeJsonLine(message: unknown): string;
+export interface LineDecoder {
+    push(chunk: Buffer | string): void;
+}
+export declare function createLineDecoder(onMessage: (value: unknown) => void, onParseError?: (raw: string, error: unknown) => void): LineDecoder;

package/packages/lsp-daemon/dist/socket-jsonrpc.js

@@ -0,0 +1,25 @@
+export function encodeJsonLine(message) {
+    return `${JSON.stringify(message)}\n`;
+}
+export function createLineDecoder(onMessage, onParseError) {
+    let buffer = "";
+    return {
+        push(chunk) {
+            buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+            let index = buffer.indexOf("\n");
+            while (index !== -1) {
+                const raw = buffer.slice(0, index).trim();
+                buffer = buffer.slice(index + 1);
+                if (raw.length > 0) {
+                    try {
+                        onMessage(JSON.parse(raw));
+                    }
+                    catch (error) {
+                        onParseError?.(raw, error);
+                    }
+                }
+                index = buffer.indexOf("\n");
+            }
+        },
+    };
+}

package/packages/lsp-daemon/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@code-yeongyu/lsp-daemon",
+	"version": "0.1.0",
+	"description": "Shared per-user Language Server Protocol daemon over a unix socket, with a stdio MCP proxy and a tool client.",
+	"type": "module",
+	"packageManager": "npm@11.16.0",
+	"license": "MIT",
+	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
+	"bin": {
+		"omo-lsp-daemon": "./dist/cli.js"
+	},
+	"files": [
+		"dist",
+		"LICENSE",
+		"NOTICE",
+		"README.md"
+	],
+	"scripts": {
+		"build": "tsc -p tsconfig.build.json && bun build src/cli.ts src/index.ts --outdir dist --target node --format esm && node scripts/stamp-dist-version.mjs",
+		"test": "vitest --run",
+		"test:watch": "vitest",
+		"typecheck": "tsc --noEmit",
+		"lint": "biome check .",
+		"lint:fix": "biome check --write .",
+		"check": "tsc --noEmit && biome check . && npm run build"
+	},
+	"devDependencies": {
+		"@biomejs/biome": "2.4.16",
+		"@code-yeongyu/lsp-tools-mcp": "file:../lsp-tools-mcp",
+		"@types/node": "^25.9.2",
+		"typescript": "^6.0.3",
+		"vitest": "^4.1.8"
+	},
+	"engines": {
+		"node": ">=20.0.0"
+	}
+}

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

@@ -1,7 +1,10 @@
 import { existsSync, statSync } from "node:fs";
-import { dirname, extname, join, resolve } from "node:path";
+import { dirname, join, resolve } from "node:path";
+import { contextCwd } from "../request-context.js";
+import { effectiveExtension } from "./effective-extension.js";
 import { isLspDeadConnectionError, LspInvalidPathError, LspRequestTimeoutError, LspServerInitializingError, LspServerLookupError, } from "./errors.js";
 import { getLspManager } from "./manager.js";
+import { loadInstallDecision } from "./server-install-state.js";
 import { findServerForExtension } from "./server-resolution.js";
 const WORKSPACE_MARKERS = [".git", "package.json", "pyproject.toml", "Cargo.toml", "go.mod", "pom.xml", "build.gradle"];
 export function isDirectoryPath(filePath) {
@@ -13,7 +16,7 @@ export function isDirectoryPath(filePath) {
     }
 }
 export function findWorkspaceRoot(filePath) {
-    const abs = resolve(filePath);
+    const abs = resolve(contextCwd(), filePath);
     let dir = abs;
     if (!isDirectoryPath(dir)) {
         dir = dirname(dir);
@@ -32,19 +35,7 @@ export function findWorkspaceRoot(filePath) {
 }
 export function formatServerLookupError(result) {
     if (result.status === "not_installed") {
-        const { server, installHint } = result;
-        return [
-            `LSP server '${server.id}' is configured but NOT INSTALLED.`,
-            "",
-            `Command not found: ${server.command[0]}`,
-            "",
-            "To install:",
-            `  ${installHint}`,
-            "",
-            `Supported extensions: ${server.extensions.join(", ")}`,
-            "",
-            "After installation, the server will be available automatically.",
-        ].join("\n");
+        return formatNotInstalled(result);
     }
     return [
         `No LSP server configured for extension: ${result.extension}`,
@@ -62,6 +53,38 @@ export function formatServerLookupError(result) {
         "  }",
     ].join("\n");
 }
+function formatNotInstalled(result) {
+    const { server, installHint } = result;
+    const extensions = server.extensions.join(", ");
+    const decision = loadInstallDecision(server.id)?.decision;
+    if (decision === "declined") {
+        return `LSP server '${server.id}' (${extensions}) is NOT INSTALLED; user previously declined installation — proceed without LSP.`;
+    }
+    const header = [
+        `LSP server '${server.id}' for ${extensions} is NOT INSTALLED.`,
+        "",
+        `Command not found: ${server.command[0]}`,
+        "",
+    ];
+    if (decision === "allowed") {
+        return [
+            ...header,
+            "The user has pre-authorized LSP installation. Run the install command, then retry this tool:",
+            `  ${installHint}`,
+        ].join("\n");
+    }
+    return [
+        ...header,
+        "To install, run:",
+        `  ${installHint}`,
+        "",
+        "ACTION REQUIRED — ASK THE USER whether to install this LSP server.",
+        "- If the user agrees: run the install command above, then retry this tool.",
+        "- If the user declines, OR has NOT explicitly asked for LSP installation:",
+        `    call lsp_install_decision { server_id: "${server.id}", decision: "declined" },`,
+        "    then ignore this message and proceed WITHOUT LSP.",
+    ].join("\n");
+}
 const READ_ONLY_RETRY_TOOLS = new Set([
     "diagnostics",
     "definition",
@@ -71,12 +94,12 @@ const READ_ONLY_RETRY_TOOLS = new Set([
     "prepareRename",
 ]);
 export async function withLspClient(filePath, fn, toolName, options = {}) {
-    const absPath = resolve(filePath);
+    const absPath = resolve(contextCwd(), filePath);
     if (isDirectoryPath(absPath)) {
         throw new LspInvalidPathError("Directory paths are not supported by this LSP tool. " +
             "Use lsp.diagnostics with a directory path for directory diagnostics.");
     }
-    const ext = extname(absPath);
+    const ext = effectiveExtension(absPath);
     const result = findServerForExtension(ext);
     if (result.status !== "found") {
         throw new LspServerLookupError(formatServerLookupError(result));

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

@@ -1,7 +1,9 @@
 import { readFileSync } from "node:fs";
-import { extname, resolve } from "node:path";
+import { resolve } from "node:path";
 import { pathToFileURL } from "node:url";
+import { contextCwd } from "../request-context.js";
 import { LspClientConnection } from "./connection.js";
+import { effectiveExtension } from "./effective-extension.js";
 import { getLanguageId } from "./language-mappings.js";
 const POST_OPEN_DELAY_MS = 1000;
 const POST_DIAGNOSTICS_WAIT_MS = 500;
@@ -17,11 +19,11 @@ export class LspClient extends LspClientConnection {
         return this.diagnosticPullErrors;
     }
     async openFile(filePath) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         const uri = pathToFileURL(absPath).href;
         const text = readFileSync(absPath, "utf-8");
         if (!this.openedFiles.has(absPath)) {
-            const ext = extname(absPath);
+            const ext = effectiveExtension(absPath);
             const languageId = getLanguageId(ext);
             const version = 1;
             await this.sendNotification("textDocument/didOpen", {
@@ -55,7 +57,7 @@ export class LspClient extends LspClientConnection {
         });
     }
     async definition(filePath, line, character) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         await this.openFile(absPath);
         return this.sendRequest("textDocument/definition", {
             textDocument: { uri: pathToFileURL(absPath).href },
@@ -63,7 +65,7 @@ export class LspClient extends LspClientConnection {
         });
     }
     async references(filePath, line, character, includeDeclaration = true) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         await this.openFile(absPath);
         return this.sendRequest("textDocument/references", {
             textDocument: { uri: pathToFileURL(absPath).href },
@@ -72,7 +74,7 @@ export class LspClient extends LspClientConnection {
         });
     }
     async documentSymbols(filePath) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         await this.openFile(absPath);
         return this.sendRequest("textDocument/documentSymbol", {
             textDocument: { uri: pathToFileURL(absPath).href },
@@ -90,7 +92,7 @@ export class LspClient extends LspClientConnection {
         return /unsupported|not supported|method not found|unknown request/i.test(error.message);
     }
     async diagnostics(filePath) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         const uri = pathToFileURL(absPath).href;
         await this.openFile(absPath);
         await new Promise((r) => setTimeout(r, POST_DIAGNOSTICS_WAIT_MS));
@@ -110,7 +112,7 @@ export class LspClient extends LspClientConnection {
         return { items: this.getStoredDiagnostics(uri) };
     }
     async prepareRename(filePath, line, character) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         await this.openFile(absPath);
         return this.sendRequest("textDocument/prepareRename", {
             textDocument: { uri: pathToFileURL(absPath).href },
@@ -118,7 +120,7 @@ export class LspClient extends LspClientConnection {
         });
     }
     async rename(filePath, line, character, newName) {
-        const absPath = resolve(filePath);
+        const absPath = resolve(contextCwd(), filePath);
         await this.openFile(absPath);
         return this.sendRequest("textDocument/rename", {
             textDocument: { uri: pathToFileURL(absPath).href },

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

@@ -1,6 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { delimiter, isAbsolute, join } from "node:path";
+import { contextCwd, contextEnv } from "../request-context.js";
 import { BUILTIN_SERVERS } from "./server-definitions.js";
 export function getConfigPaths() {
     return {
@@ -9,18 +10,17 @@ export function getConfigPaths() {
     };
 }
 function resolveProjectConfigPath(path) {
-    const cwd = process.cwd();
-    return isAbsolute(path) ? path : join(cwd, path);
+    return isAbsolute(path) ? path : join(contextCwd(), path);
 }
 function getProjectConfigPaths() {
-    const projectOverride = process.env["LSP_TOOLS_MCP_PROJECT_CONFIG"];
+    const projectOverride = contextEnv("LSP_TOOLS_MCP_PROJECT_CONFIG");
     if (projectOverride) {
         return projectOverride.split(delimiter).filter(Boolean).map(resolveProjectConfigPath);
     }
-    return [join(process.cwd(), ".codex", "lsp-client.json")];
+    return [join(contextCwd(), ".codex", "lsp-client.json")];
 }
 function getUserConfigPath() {
-    const userOverride = process.env["LSP_TOOLS_MCP_USER_CONFIG"];
+    const userOverride = contextEnv("LSP_TOOLS_MCP_USER_CONFIG");
     if (!userOverride)
         return join(homedir(), ".codex", "lsp-client.json");
     return isAbsolute(userOverride) ? userOverride : join(homedir(), userOverride);

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

@@ -1,7 +1,9 @@
 import { existsSync, lstatSync, readdirSync } from "node:fs";
-import { extname, join, resolve } from "node:path";
+import { join, resolve } from "node:path";
+import { contextCwd } from "../request-context.js";
 import { findWorkspaceRoot, formatServerLookupError } from "./client-wrapper.js";
 import { DEFAULT_MAX_DIAGNOSTICS, DEFAULT_MAX_DIRECTORY_FILES } from "./constants.js";
+import { effectiveExtension } from "./effective-extension.js";
 import { LspInvalidPathError, LspServerLookupError } from "./errors.js";
 import { filterDiagnosticsBySeverity, formatDiagnostic } from "./formatters.js";
 import { getLspManager } from "./manager.js";
@@ -37,7 +39,7 @@ export function collectFilesWithExtension(dir, extension, maxFiles) {
                     walk(fullPath);
                 }
             }
-            else if (stat.isFile() && extname(fullPath) === extension) {
+            else if (stat.isFile() && effectiveExtension(fullPath) === extension) {
                 files.push(fullPath);
             }
         }
@@ -49,7 +51,7 @@ export async function aggregateDiagnosticsForDirectory(directory, extension, sev
     if (!extension.startsWith(".")) {
         throw new LspInvalidPathError(`Extension must start with a dot (e.g., ".ts", not "${extension}"). Use ".${extension}" instead.`);
     }
-    const absDir = resolve(directory);
+    const absDir = resolve(contextCwd(), directory);
     if (!existsSync(absDir)) {
         throw new LspInvalidPathError(`Directory does not exist: ${absDir}`);
     }

package/packages/lsp-tools-mcp/dist/lsp/effective-extension.d.ts

@@ -0,0 +1 @@
+export declare function effectiveExtension(filePath: string): string;

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

@@ -0,0 +1,8 @@
+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/infer-extension.js

@@ -1,5 +1,6 @@
 import { lstatSync, readdirSync } from "node:fs";
-import { extname, join } from "node:path";
+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;
@@ -36,7 +37,7 @@ export function inferExtensionFromDirectory(directory) {
                 }
             }
             else if (stat.isFile()) {
-                const ext = extname(fullPath);
+                const ext = effectiveExtension(fullPath);
                 if (ext && ext in EXT_TO_LANG) {
                     extensionCounts.set(ext, (extensionCounts.get(ext) ?? 0) + 1);
                 }

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

@@ -76,6 +76,7 @@ export const EXT_TO_LANG = {
     ".htm": "html",
     ".ini": "ini",
     ".java": "java",
+    ".jl": "julia",
     ".js": "javascript",
     ".jsx": "javascriptreact",
     ".json": "json",