kritya 0.8.2-beta

package/dist/lsp/client.js

@@ -0,0 +1,413 @@
+import { spawn } from "node:child_process";
+import fs from "node:fs/promises";
+import { pathToFileURL } from "node:url";
+import { languageIdForFile } from "./registry.js";
+const REQUEST_TIMEOUT_MS = 15_000;
+/**
+ * Minimal LSP client over stdio. Implements only what the lsp_* tools need:
+ * initialize, didOpen/didChange full-text sync, definition, references, and
+ * collecting publishDiagnostics pushes. Deliberately dependency-free — the
+ * framing and dispatch below is the whole protocol surface we use.
+ */
+export class LspClient {
+    config;
+    workspace;
+    proc = null;
+    nextId = 1;
+    pending = new Map();
+    buffer = Buffer.alloc(0);
+    initPromise = null;
+    /** version + last-synced text per open document, keyed by absolute path. */
+    openDocs = new Map();
+    /** Latest diagnostics push per document URI, with a receipt counter for waiting. */
+    diagnostics = new Map();
+    diagStamp = 0;
+    diagWaiters = new Set();
+    /** Progress tokens with an active begin — nonempty means the server is still indexing. */
+    activeProgress = new Set();
+    progressWaiters = new Set();
+    /** Set when the server process exits or errors; the manager respawns on next use. */
+    dead = false;
+    deathReason = "";
+    constructor(config, workspace) {
+        this.config = config;
+        this.workspace = workspace;
+    }
+    /** Spawn the server and run the initialize handshake. Rejects if the binary is missing. */
+    start() {
+        if (!this.initPromise)
+            this.initPromise = this.doStart();
+        return this.initPromise;
+    }
+    doStart() {
+        return new Promise((resolve, reject) => {
+            const proc = spawn(this.config.command, this.config.args, {
+                cwd: this.workspace,
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            this.proc = proc;
+            proc.on("error", (err) => {
+                this.markDead(err.code === "ENOENT"
+                    ? `'${this.config.command}' is not installed (install: ${this.config.installHint})`
+                    : `failed to start '${this.config.command}': ${err.message}`);
+                reject(new Error(this.deathReason));
+            });
+            proc.on("exit", (code) => {
+                this.markDead(`language server '${this.config.command}' exited (code ${code})`);
+            });
+            proc.stdout.on("data", (chunk) => this.onData(chunk));
+            // stderr is ignored: language servers log progress there and it is not
+            // useful to the model; a crash surfaces via the exit handler instead.
+            proc.stderr.resume();
+            this.request("initialize", {
+                processId: process.pid,
+                rootUri: pathToFileURL(this.workspace).href,
+                workspaceFolders: [{ uri: pathToFileURL(this.workspace).href, name: "workspace" }],
+                capabilities: {
+                    textDocument: {
+                        synchronization: { didSave: false },
+                        definition: { linkSupport: true },
+                        references: {},
+                        hover: { contentFormat: ["markdown", "plaintext"] },
+                        rename: { prepareSupport: false },
+                        publishDiagnostics: {},
+                    },
+                    workspace: { configuration: true, workspaceFolders: true },
+                    // Lets the server report indexing/project-load progress, which
+                    // waitForIndexing uses to avoid answering queries from a
+                    // half-loaded project (tsserver, gopls, and rust-analyzer all
+                    // return incomplete references until their initial scan finishes).
+                    window: { workDoneProgress: true },
+                },
+            })
+                .then(() => {
+                this.notify("initialized", {});
+                resolve();
+            })
+                .catch(reject);
+        });
+    }
+    markDead(reason) {
+        if (this.dead)
+            return;
+        this.dead = true;
+        this.deathReason = reason;
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error(reason));
+        }
+        this.pending.clear();
+        this.wakeDiagWaiters();
+        this.wakeProgressWaiters();
+    }
+    dispose() {
+        if (this.proc && !this.dead) {
+            // Fire-and-forget shutdown; kill regardless so we never hang on exit.
+            this.notify("exit", undefined);
+            this.proc.kill();
+        }
+        this.markDead("client disposed");
+    }
+    // ---- JSON-RPC transport -------------------------------------------------
+    send(msg) {
+        if (!this.proc || this.dead)
+            return;
+        const body = Buffer.from(JSON.stringify({ jsonrpc: "2.0", ...msg }), "utf8");
+        this.proc.stdin.write(`Content-Length: ${body.length}\r\n\r\n`);
+        this.proc.stdin.write(body);
+    }
+    request(method, params, timeoutMs = REQUEST_TIMEOUT_MS) {
+        if (this.dead)
+            return Promise.reject(new Error(this.deathReason));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`LSP request '${method}' timed out after ${timeoutMs / 1000}s`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve, reject, timer });
+            this.send({ id, method, params });
+        });
+    }
+    notify(method, params) {
+        this.send({ method, params });
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        for (;;) {
+            const headerEnd = this.buffer.indexOf("\r\n\r\n");
+            if (headerEnd === -1)
+                return;
+            const header = this.buffer.subarray(0, headerEnd).toString("ascii");
+            const match = /Content-Length:\s*(\d+)/i.exec(header);
+            if (!match) {
+                // Malformed frame — drop the header and resync rather than spinning.
+                this.buffer = this.buffer.subarray(headerEnd + 4);
+                continue;
+            }
+            const length = Number(match[1]);
+            const bodyStart = headerEnd + 4;
+            if (this.buffer.length < bodyStart + length)
+                return;
+            const body = this.buffer.subarray(bodyStart, bodyStart + length).toString("utf8");
+            this.buffer = this.buffer.subarray(bodyStart + length);
+            try {
+                this.onMessage(JSON.parse(body));
+            }
+            catch {
+                // Unparseable frame from the server; skip it.
+            }
+        }
+    }
+    onMessage(msg) {
+        if (msg.id !== undefined && msg.method) {
+            this.onServerRequest(msg);
+        }
+        else if (msg.id !== undefined) {
+            const p = this.pending.get(Number(msg.id));
+            if (!p)
+                return;
+            this.pending.delete(Number(msg.id));
+            clearTimeout(p.timer);
+            if (msg.error)
+                p.reject(new Error(`${msg.method ?? "LSP"}: ${msg.error.message}`));
+            else
+                p.resolve(msg.result);
+        }
+        else if (msg.method === "textDocument/publishDiagnostics") {
+            const params = msg.params;
+            this.diagnostics.set(params.uri, { items: params.diagnostics, stamp: ++this.diagStamp });
+            this.wakeDiagWaiters();
+        }
+        else if (msg.method === "$/progress") {
+            const params = msg.params;
+            if (params.value?.kind === "begin")
+                this.activeProgress.add(params.token);
+            else if (params.value?.kind === "end")
+                this.activeProgress.delete(params.token);
+            this.wakeProgressWaiters();
+        }
+        // Other notifications (logMessage, progress, ...) are irrelevant here.
+    }
+    /** Servers block waiting for answers to their own requests — respond to the common ones. */
+    onServerRequest(msg) {
+        switch (msg.method) {
+            case "workspace/configuration": {
+                const items = msg.params?.items ?? [];
+                this.send({ id: msg.id, result: items.map(() => null) });
+                break;
+            }
+            case "client/registerCapability":
+            case "client/unregisterCapability":
+            case "window/workDoneProgress/create":
+                this.send({ id: msg.id, result: null });
+                break;
+            case "workspace/applyEdit":
+                this.send({ id: msg.id, result: { applied: false } });
+                break;
+            default:
+                this.send({ id: msg.id, error: { code: -32601, message: "method not supported" } });
+        }
+    }
+    // ---- document sync ------------------------------------------------------
+    /**
+     * Ensure the server has the current on-disk content of `absPath`.
+     * Returns the document URI and whether a (re)sync was actually sent —
+     * callers use that to know if fresh diagnostics are on the way.
+     */
+    async syncDocument(absPath) {
+        const uri = pathToFileURL(absPath).href;
+        const text = await fs.readFile(absPath, "utf8");
+        const open = this.openDocs.get(absPath);
+        if (!open) {
+            this.openDocs.set(absPath, { version: 1, text });
+            this.notify("textDocument/didOpen", {
+                textDocument: {
+                    uri,
+                    languageId: languageIdForFile(this.config, absPath),
+                    version: 1,
+                    text,
+                },
+            });
+            return { uri, changed: true };
+        }
+        if (open.text !== text) {
+            open.version++;
+            open.text = text;
+            this.notify("textDocument/didChange", {
+                textDocument: { uri, version: open.version },
+                contentChanges: [{ text }],
+            });
+            return { uri, changed: true };
+        }
+        return { uri, changed: false };
+    }
+    /**
+     * Wait for the server's active indexing/project-load progress to finish
+     * (bounded). Definition/references answered mid-load silently miss
+     * cross-file results, which is worse than a short delay. `justSynced`
+     * grants a grace period for the "begin" notification to arrive at all —
+     * project loading only starts after the first didOpen.
+     */
+    async waitForIndexing(justSynced, timeoutMs = 15_000) {
+        const deadline = Date.now() + timeoutMs;
+        if (justSynced && this.activeProgress.size === 0) {
+            const grace = Date.now() + 700;
+            while (Date.now() < grace && this.activeProgress.size === 0 && !this.dead) {
+                await this.waitForProgressChange(grace - Date.now());
+            }
+        }
+        while (this.activeProgress.size > 0 && Date.now() < deadline && !this.dead) {
+            await this.waitForProgressChange(deadline - Date.now());
+        }
+    }
+    waitForProgressChange(maxMs) {
+        return new Promise((resolve) => {
+            const done = () => {
+                clearTimeout(timer);
+                this.progressWaiters.delete(done);
+                resolve();
+            };
+            const timer = setTimeout(done, Math.max(50, Math.min(maxMs, 500)));
+            this.progressWaiters.add(done);
+        });
+    }
+    wakeProgressWaiters() {
+        const waiters = [...this.progressWaiters];
+        this.progressWaiters.clear();
+        for (const w of waiters)
+            w();
+    }
+    // ---- feature requests ---------------------------------------------------
+    async definition(absPath, position) {
+        const { uri, changed } = await this.syncDocument(absPath);
+        await this.waitForIndexing(changed);
+        const result = await this.request("textDocument/definition", {
+            textDocument: { uri },
+            position,
+        });
+        return normalizeLocations(result);
+    }
+    async references(absPath, position) {
+        const { uri, changed } = await this.syncDocument(absPath);
+        await this.waitForIndexing(changed);
+        const result = await this.request("textDocument/references", {
+            textDocument: { uri },
+            position,
+            context: { includeDeclaration: true },
+        });
+        return normalizeLocations(result);
+    }
+    /**
+     * Resolved type/signature/doc for the symbol at a position, as rendered by
+     * the server (markdown or plain text). Returns null when the server has
+     * nothing to show there.
+     */
+    async hover(absPath, position) {
+        const { uri, changed } = await this.syncDocument(absPath);
+        await this.waitForIndexing(changed);
+        const result = await this.request("textDocument/hover", {
+            textDocument: { uri },
+            position,
+        });
+        return extractHover(result);
+    }
+    /**
+     * Ask the server for a project-wide rename of the symbol at a position.
+     * Returns the edits grouped per file — the server does NOT touch disk, the
+     * caller applies them. An empty array means the symbol can't be renamed
+     * there (keyword, literal, or a server that refused).
+     */
+    async rename(absPath, position, newName) {
+        const { uri, changed } = await this.syncDocument(absPath);
+        await this.waitForIndexing(changed);
+        const result = await this.request("textDocument/rename", {
+            textDocument: { uri },
+            position,
+            newName,
+        });
+        return normalizeWorkspaceEdit(result);
+    }
+    /**
+     * Sync the file and return its diagnostics. Diagnostics are pushed by the
+     * server asynchronously, so after a (re)sync we wait for the next push for
+     * this URI, up to `timeoutMs` — servers analyzing a large project for the
+     * first time may deliver later, in which case the last-known set is returned.
+     */
+    async diagnosticsFor(absPath, timeoutMs = 8_000) {
+        const { uri, changed } = await this.syncDocument(absPath);
+        const before = this.diagnostics.get(uri)?.stamp ?? 0;
+        if (!changed && before > 0)
+            return this.diagnostics.get(uri).items;
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline && !this.dead) {
+            const current = this.diagnostics.get(uri);
+            if (current && current.stamp > before)
+                return current.items;
+            await this.waitForDiagPush(deadline - Date.now());
+        }
+        return this.diagnostics.get(uri)?.items ?? [];
+    }
+    waitForDiagPush(maxMs) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(done, Math.max(50, Math.min(maxMs, 1000)));
+            const waiter = done;
+            this.diagWaiters.add(waiter);
+            function done() {
+                clearTimeout(timer);
+                resolve();
+            }
+        });
+    }
+    wakeDiagWaiters() {
+        const waiters = [...this.diagWaiters];
+        this.diagWaiters.clear();
+        for (const w of waiters)
+            w();
+    }
+}
+/** Flatten a WorkspaceEdit (either `changes` map or `documentChanges` array) to per-file edits. */
+function normalizeWorkspaceEdit(result) {
+    if (!result || typeof result !== "object")
+        return [];
+    const edit = result;
+    if (edit.documentChanges) {
+        // documentChanges may also carry create/rename/delete ops (no textDocument); skip those.
+        return edit.documentChanges
+            .filter((c) => c.textDocument && Array.isArray(c.edits))
+            .map((c) => ({ uri: c.textDocument.uri, edits: c.edits }));
+    }
+    if (edit.changes) {
+        return Object.entries(edit.changes).map(([uri, edits]) => ({ uri, edits }));
+    }
+    return [];
+}
+/** Hover contents can be MarkupContent, a MarkedString, or an array of them; flatten to text. */
+function extractHover(result) {
+    const contents = result?.contents;
+    if (contents === undefined || contents === null)
+        return null;
+    const parts = [];
+    const push = (v) => {
+        if (typeof v === "string")
+            parts.push(v);
+        else if (v && typeof v === "object" && "value" in v)
+            parts.push(String(v.value));
+    };
+    if (Array.isArray(contents))
+        contents.forEach(push);
+    else
+        push(contents);
+    const text = parts.join("\n\n").trim();
+    return text.length > 0 ? text : null;
+}
+/** Servers return Location | Location[] | LocationLink[] | null; flatten to Location[]. */
+function normalizeLocations(result) {
+    if (!result)
+        return [];
+    const items = Array.isArray(result) ? result : [result];
+    return items.map((item) => "targetUri" in item
+        ? { uri: item.targetUri, range: item.targetSelectionRange }
+        : { uri: item.uri, range: item.range });
+}

package/dist/lsp/registry.js

@@ -0,0 +1,62 @@
+import path from "node:path";
+const SERVERS = [
+    {
+        id: "typescript",
+        command: "typescript-language-server",
+        args: ["--stdio"],
+        installHint: "npm install -g typescript-language-server typescript",
+        languageIds: {
+            ts: "typescript",
+            mts: "typescript",
+            cts: "typescript",
+            tsx: "typescriptreact",
+            js: "javascript",
+            mjs: "javascript",
+            cjs: "javascript",
+            jsx: "javascriptreact",
+        },
+    },
+    {
+        id: "python",
+        command: "pyright-langserver",
+        args: ["--stdio"],
+        installHint: "npm install -g pyright",
+        languageIds: { py: "python", pyi: "python" },
+    },
+    {
+        id: "go",
+        command: "gopls",
+        args: [],
+        installHint: "go install golang.org/x/tools/gopls@latest",
+        languageIds: { go: "go" },
+    },
+    {
+        id: "rust",
+        command: "rust-analyzer",
+        args: [],
+        installHint: "rustup component add rust-analyzer",
+        languageIds: { rs: "rust" },
+    },
+    {
+        id: "clangd",
+        command: "clangd",
+        args: [],
+        installHint: "install clangd via your OS package manager (apt/brew/winget)",
+        languageIds: { c: "c", h: "c", cpp: "cpp", hpp: "cpp", cc: "cpp", cxx: "cpp", hh: "cpp" },
+    },
+];
+/** Find the language server responsible for a file, or null if none is known. */
+export function serverForFile(filePath) {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    if (!ext)
+        return null;
+    return SERVERS.find((s) => ext in s.languageIds) ?? null;
+}
+export function languageIdForFile(config, filePath) {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    return config.languageIds[ext] ?? "plaintext";
+}
+/** Extensions kritya can serve at all — used for the tool description. */
+export function supportedExtensions() {
+    return SERVERS.flatMap((s) => Object.keys(s.languageIds));
+}

package/dist/mcp/callback.js

@@ -0,0 +1,141 @@
+import { spawn } from "node:child_process";
+import http from "node:http";
+import os from "node:os";
+import { debugLog } from "../config/debug.js";
+/**
+ * The loopback half of the OAuth flow (RFC 8252): kritya runs in a terminal and
+ * must never see the user's password, so the browser does the login and hands
+ * the authorization code back over a one-shot HTTP server on 127.0.0.1.
+ *
+ * The listener binds an OS-assigned port on the loopback interface only, is
+ * created *before* dynamic client registration (the exact redirect_uri has to
+ * be registered, so the port must already be known), and shuts down the moment
+ * it has an answer. `state` is checked here rather than by the caller: a
+ * mismatched callback is an attempted CSRF, not a user-visible error case.
+ */
+const CALLBACK_TIMEOUT_MS = 5 * 60 * 1000;
+function page(title, detail) {
+    // Deliberately dependency-free and inline-styled: this renders in the user's
+    // browser, and a login callback should not fetch anything from the network.
+    return `<!doctype html><html><head><meta charset="utf-8"><title>${title}</title></head>
+<body style="font-family:system-ui,sans-serif;max-width:32rem;margin:6rem auto;padding:0 1.5rem;line-height:1.6">
+<h1 style="font-size:1.25rem;margin:0 0 .5rem">${title}</h1>
+<p style="color:#555;margin:0">${detail}</p>
+</body></html>`;
+}
+export async function startCallbackServer(state) {
+    let settle;
+    let outcome;
+    const finish = (result) => {
+        if (outcome)
+            return;
+        outcome = result;
+        if (!settle)
+            return;
+        if (result.code)
+            settle.resolve(result.code);
+        else
+            settle.reject(result.error ?? new Error("authorization failed"));
+    };
+    const server = http.createServer((req, res) => {
+        const url = new URL(req.url ?? "/", "http://127.0.0.1");
+        if (url.pathname !== "/callback") {
+            res.writeHead(404).end();
+            return;
+        }
+        const error = url.searchParams.get("error");
+        const code = url.searchParams.get("code");
+        const gotState = url.searchParams.get("state");
+        if (error) {
+            const description = url.searchParams.get("error_description") ?? error;
+            res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+            res.end(page("Login failed", description));
+            finish({ error: new Error(`authorization denied: ${description}`) });
+            return;
+        }
+        if (gotState !== state) {
+            // Someone else's callback, or a forged one. Say nothing useful to it.
+            res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+            res.end(page("Login failed", "State mismatch — this callback was ignored."));
+            finish({ error: new Error("state mismatch on OAuth callback") });
+            return;
+        }
+        if (!code) {
+            res.writeHead(400, { "content-type": "text/html; charset=utf-8" });
+            res.end(page("Login failed", "No authorization code was returned."));
+            finish({ error: new Error("no authorization code in callback") });
+            return;
+        }
+        res.writeHead(200, { "content-type": "text/html; charset=utf-8" });
+        res.end(page("kritya is connected", "You can close this tab and return to your terminal."));
+        finish({ code });
+    });
+    await new Promise((resolve, reject) => {
+        server.once("error", reject);
+        // Loopback only — never 0.0.0.0. Port 0 lets the OS pick a free one.
+        server.listen(0, "127.0.0.1", () => resolve());
+    });
+    const address = server.address();
+    const port = typeof address === "object" && address ? address.port : 0;
+    if (!port) {
+        server.close();
+        throw new Error("could not bind a loopback port for the OAuth callback");
+    }
+    const close = () => {
+        server.close();
+        server.closeAllConnections?.();
+    };
+    return {
+        redirectUri: `http://127.0.0.1:${port}/callback`,
+        waitForCode() {
+            return new Promise((resolve, reject) => {
+                settle = { resolve, reject };
+                // A callback that already arrived (fast browser, slow caller) must not
+                // be lost between listen() and waitForCode().
+                if (outcome) {
+                    if (outcome.code)
+                        resolve(outcome.code);
+                    else
+                        reject(outcome.error ?? new Error("authorization failed"));
+                    return;
+                }
+                const timer = setTimeout(() => {
+                    finish({ error: new Error("timed out waiting for the browser callback (5 minutes)") });
+                }, CALLBACK_TIMEOUT_MS);
+                timer.unref?.();
+            }).finally(close);
+        },
+        close,
+    };
+}
+/**
+ * Best-effort browser launch. Returns false when there is nothing to open —
+ * over SSH, in a container, or on a headless box — so the caller can fall back
+ * to printing the URL for the user to open somewhere else.
+ */
+export function openBrowser(url) {
+    if (process.env.KRITYA_NO_BROWSER)
+        return false;
+    // No DISPLAY/WAYLAND_DISPLAY on Linux means no browser to hand this to.
+    if (os.platform() === "linux" &&
+        !process.env.DISPLAY &&
+        !process.env.WAYLAND_DISPLAY &&
+        !process.env.WSL_DISTRO_NAME) {
+        return false;
+    }
+    const [cmd, args] = os.platform() === "win32"
+        ? ["cmd", ["/c", "start", "", url]]
+        : os.platform() === "darwin"
+            ? ["open", [url]]
+            : ["xdg-open", [url]];
+    try {
+        const child = spawn(cmd, args, { stdio: "ignore", detached: true, windowsHide: true });
+        child.on("error", (err) => debugLog(`openBrowser(${cmd})`, err));
+        child.unref();
+        return true;
+    }
+    catch (err) {
+        debugLog(`openBrowser(${cmd})`, err);
+        return false;
+    }
+}