howtofixcli 0.7.11 → 0.7.13

package/dist/lsp.js

@@ -0,0 +1,429 @@
+/**
+ * LSP over stdio: `Content-Length` framing, a stream-driven client, the server
+ * table, and `askLsp`.
+ *
+ * Client lifecycle is process-wide: one client per server command, shared by
+ * every session and subagent — two agents on one TS project must not spawn two
+ * `typescript-language-server`s. Clients are killed when the main session
+ * disposes (`disposeAllLsp` from `openSession` in `session.ts`) and on process
+ * `exit`, which is registered here. Because the pool is keyed by command, the
+ * first spawn's root wins for the process; HowToFix runs one project per
+ * process, so that is the common case by design.
+ */
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+export function encodeMessage(message) {
+    const body = JSON.stringify(message);
+    return `Content-Length: ${Buffer.byteLength(body, "utf8")}\r\n\r\n${body}`;
+}
+/**
+ * The largest frame a language server may send.
+ *
+ * A server that announces a body this big is not sending a message, it is
+ * desynchronised or hostile. Waiting for the rest of it would grow the buffer
+ * until the process dies, so the frame is refused instead.
+ */
+export const MAX_FRAME_BYTES = 32 * 1024 * 1024;
+export function decodeMessages(buffer) {
+    const messages = [];
+    let offset = 0;
+    while (offset < buffer.length) {
+        const headerEnd = buffer.indexOf("\r\n\r\n", offset);
+        if (headerEnd === -1)
+            break;
+        const header = buffer.subarray(offset, headerEnd).toString("utf8");
+        const lengthMatch = /Content-Length:\s*(\d+)/i.exec(header);
+        if (!lengthMatch)
+            break;
+        const length = Number(lengthMatch[1]);
+        if (!Number.isSafeInteger(length) || length < 0 || length > MAX_FRAME_BYTES) {
+            throw new Error(`lsp frame of ${lengthMatch[1]} bytes refused`);
+        }
+        const bodyStart = headerEnd + 4;
+        const bodyEnd = bodyStart + length;
+        if (bodyEnd > buffer.length)
+            break;
+        const body = buffer.subarray(bodyStart, bodyEnd).toString("utf8");
+        // One malformed frame is skipped, not fatal: a language server that emits a
+        // bad message must not take the CLI down in the middle of a session.
+        try {
+            const parsed = JSON.parse(body);
+            if (parsed && typeof parsed === "object")
+                messages.push(parsed);
+        }
+        catch {
+            // dropped on purpose; the stream stays aligned because the length was read
+        }
+        offset = bodyEnd;
+    }
+    return { messages, rest: buffer.subarray(offset) };
+}
+export class LspClient {
+    io;
+    nextId = 1;
+    pending = new Map();
+    buffer = Buffer.alloc(0);
+    broken = null;
+    opened = new Set();
+    diagnosticsByUri = new Map();
+    diagnosticsWaiters = new Map();
+    constructor(io) {
+        this.io = io;
+        io.stdout.on("data", (chunk) => {
+            if (this.broken)
+                return;
+            this.buffer = Buffer.concat([this.buffer, chunk]);
+            let decoded;
+            try {
+                decoded = decodeMessages(this.buffer);
+            }
+            catch (error) {
+                // A stream we cannot trust is dropped whole. Keeping it would let a
+                // desynchronised server grow the buffer without bound, and every
+                // request queued behind it would wait out its timeout for nothing.
+                this.buffer = Buffer.alloc(0);
+                this.fail(error instanceof Error ? error : new Error(String(error)));
+                return;
+            }
+            this.buffer = decoded.rest;
+            for (const message of decoded.messages)
+                this.dispatch(message);
+        });
+        // A server that dies leaves the pipe behind: the next write raises EPIPE on
+        // the stream, and with no listener that becomes an uncaught exception and
+        // takes the CLI down. Failing the client turns it into a normal error.
+        io.stdin.on("error", (error) => {
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+        });
+    }
+    /** Mark the stream unusable and answer every queued request with the reason. */
+    fail(error) {
+        if (this.broken)
+            return;
+        this.broken = error;
+        for (const [id, waiter] of this.pending) {
+            this.pending.delete(id);
+            waiter.reject(error);
+        }
+    }
+    dispatch(message) {
+        if (message.method === "textDocument/publishDiagnostics") {
+            const params = message.params;
+            if (params?.uri) {
+                const list = Array.isArray(params.diagnostics) ? params.diagnostics : [];
+                this.diagnosticsByUri.set(params.uri, list);
+                const waiters = this.diagnosticsWaiters.get(params.uri);
+                if (waiters) {
+                    this.diagnosticsWaiters.delete(params.uri);
+                    for (const waiter of waiters)
+                        waiter(list);
+                }
+            }
+            return;
+        }
+        if (message.id === undefined)
+            return; // other notifications ignored in v1
+        const waiter = this.pending.get(Number(message.id));
+        if (!waiter)
+            return;
+        this.pending.delete(Number(message.id));
+        if (message.error)
+            waiter.reject(new Error(message.error.message));
+        else
+            waiter.resolve(message.result);
+    }
+    request(method, params, timeoutMs = 10_000) {
+        if (this.broken)
+            return Promise.reject(this.broken);
+        const id = this.nextId++;
+        const payload = encodeMessage({ jsonrpc: "2.0", id, method, params });
+        const { promise, resolve, reject } = Promise.withResolvers();
+        const timer = setTimeout(() => {
+            this.pending.delete(id);
+            reject(new Error(`lsp ${method} timed out`));
+        }, timeoutMs);
+        this.pending.set(id, {
+            resolve: (value) => {
+                clearTimeout(timer);
+                resolve(value);
+            },
+            reject: (error) => {
+                clearTimeout(timer);
+                reject(error);
+            },
+        });
+        try {
+            this.io.stdin.write(payload);
+        }
+        catch (error) {
+            // A pipe that is already gone throws here instead of emitting; the caller
+            // must see a failure, not a request that waits out its timeout.
+            const reason = error instanceof Error ? error : new Error(String(error));
+            this.pending.delete(id);
+            clearTimeout(timer);
+            reject(reason);
+            this.fail(reason);
+        }
+        return promise;
+    }
+    notify(method, params) {
+        if (this.broken)
+            return;
+        try {
+            this.io.stdin.write(encodeMessage({ jsonrpc: "2.0", method, params }));
+        }
+        catch (error) {
+            // Notifications have no caller waiting, so a dead pipe would surface as an
+            // uncaught exception from a fire-and-forget write. Record it instead.
+            this.fail(error instanceof Error ? error : new Error(String(error)));
+        }
+    }
+    async initialize() {
+        await this.request("initialize", {
+            processId: null,
+            rootUri: pathToFileURL(this.io.root).toString(),
+            capabilities: { textDocument: { hover: {}, definition: {}, references: {}, documentSymbol: {}, publishDiagnostics: {} } },
+        });
+        this.notify("initialized", {});
+    }
+    // Positions are 0-based on the wire; callers that take editor-style 1-based lines subtract one before calling.
+    async hover(file, line, character) {
+        const result = (await this.request("textDocument/hover", {
+            textDocument: { uri: pathToFileURL(file).toString() },
+            position: { line, character },
+        }));
+        return result?.contents?.value;
+    }
+    async definition(file, line, character) {
+        const result = (await this.request("textDocument/definition", {
+            textDocument: { uri: pathToFileURL(file).toString() },
+            position: { line, character },
+        }));
+        if (Array.isArray(result))
+            return result[0];
+        return result ?? undefined;
+    }
+    async references(file, line, character) {
+        const result = await this.request("textDocument/references", {
+            textDocument: { uri: pathToFileURL(file).toString() },
+            position: { line, character },
+            context: { includeDeclaration: true },
+        });
+        return Array.isArray(result) ? result : [];
+    }
+    async documentSymbols(file) {
+        const result = await this.request("textDocument/documentSymbol", {
+            textDocument: { uri: pathToFileURL(file).toString() },
+        });
+        return Array.isArray(result) ? result : [];
+    }
+    /**
+     * Stored `publishDiagnostics` for the file, waiting up to `timeoutMs` for the
+     * first publish. A server that never publishes gets `[]`, never a hang.
+     */
+    diagnostics(file, timeoutMs = 2_000) {
+        const uri = pathToFileURL(file).toString();
+        const stored = this.diagnosticsByUri.get(uri);
+        if (stored)
+            return Promise.resolve(stored);
+        const { promise, resolve } = Promise.withResolvers();
+        const timer = setTimeout(() => {
+            const waiters = this.diagnosticsWaiters.get(uri);
+            if (waiters) {
+                this.diagnosticsWaiters.delete(uri);
+                for (const waiter of waiters)
+                    waiter(this.diagnosticsByUri.get(uri) ?? []);
+            }
+        }, timeoutMs);
+        const waiters = this.diagnosticsWaiters.get(uri) ?? [];
+        waiters.push((value) => {
+            clearTimeout(timer);
+            resolve(value);
+        });
+        this.diagnosticsWaiters.set(uri, waiters);
+        return promise;
+    }
+    async ensureOpen(file, text, languageId) {
+        const uri = pathToFileURL(file).toString();
+        if (this.opened.has(uri))
+            return;
+        this.notify("textDocument/didOpen", {
+            textDocument: { uri, languageId, version: 1, text },
+        });
+        this.opened.add(uri);
+    }
+    dispose() {
+        for (const [id, waiter] of this.pending) {
+            waiter.reject(new Error("lsp client disposed"));
+            this.pending.delete(id);
+        }
+        // Flush diagnostic waiters so a dispose mid-query answers [] instead of
+        // leaving the timer to fire into a dead client.
+        for (const [uri, waiters] of this.diagnosticsWaiters) {
+            const stored = this.diagnosticsByUri.get(uri) ?? [];
+            this.diagnosticsWaiters.delete(uri);
+            for (const waiter of waiters)
+                waiter(stored);
+        }
+    }
+}
+export const SERVERS = [
+    {
+        command: "typescript-language-server",
+        args: ["--stdio"],
+        languageId: "typescript",
+        match: (file) => /\.(ts|tsx|js|jsx|mts|cts)$/.test(file),
+    },
+    { command: "rust-analyzer", args: [], languageId: "rust", match: (file) => file.endsWith(".rs") },
+    { command: "gopls", args: [], languageId: "go", match: (file) => file.endsWith(".go") },
+    { command: "pylsp", args: [], languageId: "python", match: (file) => file.endsWith(".py") },
+];
+export function specFor(file) {
+    return SERVERS.find((spec) => spec.match(file));
+}
+/** Process-wide, keyed by server command (see the header): every session and
+ *  subagent shares one server per language. */
+const clients = new Map();
+async function clientFor(spec, root) {
+    const existing = clients.get(spec.command);
+    if (existing) {
+        await existing.ready;
+        return existing.client;
+    }
+    // cwd is the session's project root, not the file's directory: gopls and
+    // rust-analyzer want the module root, and `rootUri` is set from it too.
+    const child = spawn(spec.command, spec.args, { cwd: root, stdio: ["pipe", "pipe", "ignore"] });
+    const stdin = child.stdin;
+    const stdout = child.stdout;
+    if (!stdin || !stdout) {
+        child.kill();
+        throw new Error(`${spec.command}: stdio pipes unavailable`);
+    }
+    const client = new LspClient({ stdin, stdout, root });
+    // A spawn that fails after the PATH check (EACCES, a stale symlink) must not
+    // crash the process on an unhandled 'error' event or leave a corpse pooled.
+    child.on("error", () => {
+        const pooled = clients.get(spec.command);
+        if (pooled?.child === child)
+            clients.delete(spec.command);
+        pooled?.client.dispose();
+    });
+    // A server that dies on its own has to leave the pool, or every later query
+    // for this language talks to a client whose pipes are gone and waits out a
+    // timeout before failing.
+    child.on("exit", () => {
+        const pooled = clients.get(spec.command);
+        if (pooled?.child === child)
+            clients.delete(spec.command);
+        client.dispose();
+    });
+    const ready = client.initialize().catch((error) => {
+        clients.delete(spec.command);
+        child.kill();
+        throw error;
+    });
+    clients.set(spec.command, { client, child, ready });
+    await ready;
+    return client;
+}
+/**
+ * Kill every pooled server. Called from the main session's `dispose`
+ * (`openSession` in `session.ts`) and on process `exit` — subagent sessions
+ * share the pool, so only the process-wide teardown kills it (see the header).
+ */
+export function disposeAllLsp() {
+    for (const [command, pooled] of clients) {
+        clients.delete(command);
+        pooled.client.dispose();
+        pooled.child.kill();
+    }
+}
+process.on("exit", disposeAllLsp);
+const SEVERITY_NAME = { 1: "error", 2: "warning", 3: "info", 4: "hint" };
+function locationText(location) {
+    let file = location.uri;
+    try {
+        file = fileURLToPath(location.uri);
+    }
+    catch {
+        // Not a file:// uri — a workspace or virtual scheme; show it as it came.
+    }
+    const start = location.range?.start;
+    return start ? `${file}:${start.line + 1}:${start.character + 1}` : file;
+}
+function symbolRows(symbols, depth = 0) {
+    const rows = [];
+    for (const symbol of symbols) {
+        const line = (symbol.selectionRange ?? symbol.range)?.start.line;
+        rows.push(`${"  ".repeat(depth)}${symbol.name}${line === undefined ? "" : ` :${line + 1}`}`);
+        if (symbol.children)
+            rows.push(...symbolRows(symbol.children, depth + 1));
+    }
+    return rows;
+}
+/**
+ * Run one language-server query. Every failure mode — no server for this file,
+ * a missing binary, no line, an unreadable file, a dead child — comes back as
+ * `{ ok: false, error }`; the tool contract is results, never throws.
+ */
+export async function askLsp(query) {
+    try {
+        const spec = specFor(query.file);
+        if (!spec)
+            return { ok: false, error: `no language server configured for ${query.file}` };
+        const needsLine = query.action === "definition" || query.action === "references" || query.action === "hover";
+        if (needsLine && (query.line === undefined || !Number.isInteger(query.line) || query.line < 1)) {
+            return { ok: false, error: `line required (1-based) for ${query.action}` };
+        }
+        // PATH presence is checked by scanning, not by spawning: a missing binary
+        // has to become a tool result, and a probe child would cost a fork per call.
+        const onPath = spec.command.includes("/") ? existsSync(spec.command) : (process.env.PATH ?? "").split(delimiter).some((dir) => existsSync(join(dir, spec.command)));
+        if (!onPath) {
+            return { ok: false, error: `${spec.command} is not on PATH. Install it to use lsp on ${query.file}.` };
+        }
+        const file = isAbsolute(query.file) ? query.file : join(query.root, query.file);
+        const text = readFileSync(file, "utf8");
+        const client = await clientFor(spec, query.root);
+        await client.ensureOpen(file, text, spec.languageId);
+        // The tool takes 1-based lines (editor habit); LSP positions on the wire
+        // are 0-based — this is that conversion.
+        const wireLine = (query.line ?? 1) - 1;
+        let character = 0;
+        if (query.symbol) {
+            const at = (text.split("\n")[wireLine] ?? "").indexOf(query.symbol);
+            if (at >= 0)
+                character = at;
+        }
+        switch (query.action) {
+            case "definition": {
+                const location = await client.definition(file, wireLine, character);
+                if (!location)
+                    return { ok: true, text: "no definition found", count: 0 };
+                return { ok: true, text: locationText(location), count: 1 };
+            }
+            case "references": {
+                const locations = await client.references(file, wireLine, character);
+                const lines = locations.map(locationText);
+                return { ok: true, text: lines.length > 0 ? lines.join("\n") : "no references found", count: lines.length };
+            }
+            case "hover": {
+                const hover = (await client.hover(file, wireLine, character))?.trim();
+                return { ok: true, text: hover ? hover : "no hover at that position" };
+            }
+            case "symbols": {
+                const rows = symbolRows(await client.documentSymbols(file));
+                return { ok: true, text: rows.length > 0 ? rows.join("\n") : "no symbols in this file", count: rows.length };
+            }
+            case "diagnostics": {
+                const diagnostics = await client.diagnostics(file);
+                const rows = diagnostics.map((d) => `${d.range.start.line + 1}:${d.range.start.character + 1} ${SEVERITY_NAME[d.severity ?? 3] ?? "info"} ${d.message}`);
+                return { ok: true, text: rows.length > 0 ? rows.join("\n") : "no diagnostics", count: rows.length };
+            }
+        }
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}