@arnilo/prism-coding-agent 0.0.24 → 0.0.26

package/dist/language/client.js

@@ -0,0 +1,290 @@
+/**
+ * Minimal JSON-RPC LSP client over child stdio (LSP 3.17 framing).
+ * Lazy start; bounded pending requests, message bytes, timeout, restart budget.
+ */
+import { spawn } from "node:child_process";
+import { encodeLspFrame, LspFrameError, LspFrameReader } from "./framing.js";
+import { LanguageIntelligenceError } from "./types.js";
+export class LspClient {
+    spec;
+    limits;
+    child;
+    reader;
+    nextId = 1;
+    pending = new Map();
+    startPromise;
+    disposed = false;
+    shuttingDown = false;
+    capabilities = {};
+    /** file URI → latest diagnostics payload from publishDiagnostics */
+    diagnosticsByUri = new Map();
+    onUnexpectedExit;
+    constructor(spec, limits, hooks) {
+        this.spec = spec;
+        this.limits = limits;
+        this.reader = new LspFrameReader(limits.maxMessageBytes);
+        this.onUnexpectedExit = hooks?.onUnexpectedExit ?? (() => { });
+    }
+    get started() {
+        return this.child !== undefined && !this.disposed;
+    }
+    async ensureStarted(signal) {
+        if (this.disposed) {
+            throw new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} is disposed`);
+        }
+        if (this.child)
+            return;
+        if (!this.startPromise) {
+            this.startPromise = this.spawnAndInitialize(signal).finally(() => {
+                this.startPromise = undefined;
+            });
+        }
+        await this.startPromise;
+    }
+    async request(method, params, signal) {
+        await this.ensureStarted(signal);
+        if (this.pending.size >= this.limits.maxPendingRequests) {
+            throw new LanguageIntelligenceError("ERR_PRISM_LSP_LIMIT", `LSP pending requests exceed ${this.limits.maxPendingRequests}`);
+        }
+        const id = this.nextId++;
+        const payload = { jsonrpc: "2.0", id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                cleanupAbort();
+                reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", `LSP request ${method} timed out after ${this.limits.requestTimeoutMs}ms`));
+            }, this.limits.requestTimeoutMs);
+            const abortHandler = () => {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+            };
+            const cleanupAbort = () => {
+                if (signal && abortHandler)
+                    signal.removeEventListener("abort", abortHandler);
+            };
+            if (signal) {
+                if (signal.aborted) {
+                    clearTimeout(timer);
+                    reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+                    return;
+                }
+                signal.addEventListener("abort", abortHandler, { once: true });
+            }
+            this.pending.set(id, { resolve, reject, timer, abortHandler, signal });
+            try {
+                this.write(payload);
+            }
+            catch (error) {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                cleanupAbort();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    notify(method, params) {
+        if (!this.child)
+            return;
+        this.write({ jsonrpc: "2.0", method, params });
+    }
+    hasCapability(key) {
+        return this.capabilities[key] !== undefined && this.capabilities[key] !== false;
+    }
+    async dispose() {
+        this.disposed = true;
+        this.shuttingDown = true;
+        this.rejectAll(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} disposed`));
+        const child = this.child;
+        this.child = undefined;
+        if (!child)
+            return;
+        try {
+            child.stdin.end();
+        }
+        catch {
+            /* ignore */
+        }
+        if (!child.killed) {
+            child.kill("SIGTERM");
+        }
+        await new Promise((resolve) => {
+            if (child.exitCode !== null) {
+                resolve();
+                return;
+            }
+            const t = setTimeout(() => {
+                child.kill("SIGKILL");
+                resolve();
+            }, 2_000);
+            child.once("exit", () => {
+                clearTimeout(t);
+                resolve();
+            });
+        });
+    }
+    write(message) {
+        if (!this.child?.stdin.writable) {
+            throw new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} stdin closed`);
+        }
+        const frame = encodeLspFrame(message);
+        if (frame.length > this.limits.maxMessageBytes + 64) {
+            // header overhead small; body already sized by JSON
+            throw new LanguageIntelligenceError("ERR_PRISM_LSP_LIMIT", "Outgoing LSP frame exceeds message byte cap");
+        }
+        this.child.stdin.write(frame);
+    }
+    async spawnAndInitialize(signal) {
+        if (signal?.aborted) {
+            throw new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP start aborted");
+        }
+        this.reader = new LspFrameReader(this.limits.maxMessageBytes);
+        const child = spawn(this.spec.command, [...this.spec.args], {
+            cwd: this.spec.cwd,
+            env: { ...process.env, ...this.spec.env },
+            stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true,
+        });
+        this.child = child;
+        child.stdout.on("data", (chunk) => {
+            try {
+                for (const msg of this.reader.push(chunk))
+                    this.onMessage(msg);
+            }
+            catch (error) {
+                this.failTransport(error);
+            }
+        });
+        child.stderr.on("data", () => {
+            /* discard; hosts can redirect via env if needed */
+        });
+        child.on("error", (error) => {
+            this.failTransport(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP spawn failed: ${error.message}`));
+        });
+        child.on("exit", (code, signalName) => {
+            if (this.disposed || this.shuttingDown)
+                return;
+            this.child = undefined;
+            this.rejectAll(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", `LSP server ${this.spec.name} exited (code=${code}, signal=${signalName})`));
+            this.onUnexpectedExit();
+        });
+        try {
+            const initResult = (await this.requestUnlocked("initialize", {
+                processId: process.pid,
+                rootUri: this.spec.rootUri,
+                capabilities: {
+                    workspace: { applyEdit: true },
+                    textDocument: {
+                        hover: { contentFormat: ["plaintext", "markdown"] },
+                        publishDiagnostics: {},
+                    },
+                },
+                workspaceFolders: [{ uri: this.spec.rootUri, name: "workspace" }],
+            }, signal));
+            this.capabilities = initResult?.capabilities ?? {};
+            this.notify("initialized", {});
+        }
+        catch (error) {
+            this.shuttingDown = true;
+            this.child = undefined;
+            try {
+                child.kill("SIGKILL");
+            }
+            catch {
+                /* ignore */
+            }
+            throw error;
+        }
+    }
+    /** Internal request used during initialize before ensureStarted recursion. */
+    requestUnlocked(method, params, signal) {
+        if (this.pending.size >= this.limits.maxPendingRequests) {
+            throw new LanguageIntelligenceError("ERR_PRISM_LSP_LIMIT", `LSP pending requests exceed ${this.limits.maxPendingRequests}`);
+        }
+        const id = this.nextId++;
+        const payload = { jsonrpc: "2.0", id, method, params };
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                cleanupAbort();
+                reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", `LSP request ${method} timed out after ${this.limits.requestTimeoutMs}ms`));
+            }, this.limits.requestTimeoutMs);
+            const abortHandler = () => {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+            };
+            const cleanupAbort = () => {
+                if (signal)
+                    signal.removeEventListener("abort", abortHandler);
+            };
+            if (signal) {
+                if (signal.aborted) {
+                    clearTimeout(timer);
+                    reject(new LanguageIntelligenceError("ERR_PRISM_LSP_TIMEOUT", "LSP request aborted"));
+                    return;
+                }
+                signal.addEventListener("abort", abortHandler, { once: true });
+            }
+            this.pending.set(id, { resolve, reject, timer, abortHandler, signal });
+            try {
+                this.write(payload);
+            }
+            catch (error) {
+                this.pending.delete(id);
+                clearTimeout(timer);
+                cleanupAbort();
+                reject(error instanceof Error ? error : new Error(String(error)));
+            }
+        });
+    }
+    onMessage(msg) {
+        if (!msg || typeof msg !== "object") {
+            throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP message is not an object");
+        }
+        const m = msg;
+        if (m.method && m.id === undefined) {
+            if (m.method === "textDocument/publishDiagnostics" && m.params && typeof m.params === "object") {
+                const p = m.params;
+                if (typeof p.uri === "string")
+                    this.diagnosticsByUri.set(p.uri, p.diagnostics ?? []);
+            }
+            return;
+        }
+        if (m.id === undefined)
+            return;
+        const id = typeof m.id === "number" ? m.id : Number(m.id);
+        const pending = this.pending.get(id);
+        if (!pending)
+            return;
+        this.pending.delete(id);
+        clearTimeout(pending.timer);
+        if (pending.signal && pending.abortHandler) {
+            pending.signal.removeEventListener("abort", pending.abortHandler);
+        }
+        if (m.error) {
+            pending.reject(new LanguageIntelligenceError("ERR_PRISM_LSP_SERVER", m.error.message ?? `LSP error code ${m.error.code}`));
+            return;
+        }
+        pending.resolve(m.result);
+    }
+    failTransport(error) {
+        const err = error instanceof LanguageIntelligenceError
+            ? error
+            : error instanceof LspFrameError
+                ? new LanguageIntelligenceError(error.code, error.message)
+                : new LanguageIntelligenceError("ERR_PRISM_LSP_FRAMING", error instanceof Error ? error.message : String(error));
+        this.rejectAll(err);
+        void this.dispose();
+    }
+    rejectAll(error) {
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            if (p.signal && p.abortHandler)
+                p.signal.removeEventListener("abort", p.abortHandler);
+            p.reject(error);
+        }
+        this.pending.clear();
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/language/framing.d.ts

@@ -0,0 +1,23 @@
+/**
+ * LSP 3.17 Content-Length framing over stdio (JSON-RPC body).
+ * No vscode-languageserver-protocol dependency.
+ */
+export type LspFrameErrorCode = "ERR_PRISM_LSP_FRAMING" | "ERR_PRISM_LSP_LIMIT";
+export declare class LspFrameError extends Error {
+    readonly code: LspFrameErrorCode;
+    constructor(code: LspFrameErrorCode, message: string);
+}
+/** Encode one JSON-RPC message as an LSP frame. */
+export declare function encodeLspFrame(message: unknown): Buffer;
+/**
+ * Incremental Content-Length frame reader.
+ * Rejects malformed headers, non-decimal Content-Length, and oversized bodies.
+ */
+export declare class LspFrameReader {
+    private buf;
+    private readonly maxMessageBytes;
+    constructor(maxMessageBytes: number);
+    /** Push stdout/stderr chunk; return complete parsed JSON values (order preserved). */
+    push(chunk: Buffer): unknown[];
+    private tryParseOne;
+}

package/dist/language/framing.js

@@ -0,0 +1,112 @@
+/**
+ * LSP 3.17 Content-Length framing over stdio (JSON-RPC body).
+ * No vscode-languageserver-protocol dependency.
+ */
+export class LspFrameError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "LspFrameError";
+        this.code = code;
+    }
+}
+/** Encode one JSON-RPC message as an LSP frame. */
+export function encodeLspFrame(message) {
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    const header = `Content-Length: ${body.length}\r\n\r\n`;
+    return Buffer.concat([Buffer.from(header, "ascii"), body]);
+}
+/**
+ * Incremental Content-Length frame reader.
+ * Rejects malformed headers, non-decimal Content-Length, and oversized bodies.
+ */
+export class LspFrameReader {
+    buf = Buffer.alloc(0);
+    maxMessageBytes;
+    constructor(maxMessageBytes) {
+        this.maxMessageBytes = maxMessageBytes;
+    }
+    /** Push stdout/stderr chunk; return complete parsed JSON values (order preserved). */
+    push(chunk) {
+        if (chunk.length === 0)
+            return [];
+        this.buf = Buffer.concat([this.buf, chunk]);
+        const out = [];
+        for (;;) {
+            const parsed = this.tryParseOne();
+            if (parsed === undefined)
+                break;
+            out.push(parsed);
+        }
+        return out;
+    }
+    tryParseOne() {
+        const sep = indexOfHeaderSep(this.buf);
+        if (sep < 0) {
+            // Bound header scan buffer so a missing separator cannot grow forever.
+            if (this.buf.length > Math.min(this.maxMessageBytes, 64 * 1024)) {
+                throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP header exceeds bound without separator");
+            }
+            return undefined;
+        }
+        const headerText = this.buf.subarray(0, sep).toString("ascii");
+        const contentLength = parseContentLength(headerText);
+        if (contentLength > this.maxMessageBytes) {
+            throw new LspFrameError("ERR_PRISM_LSP_LIMIT", `LSP message body ${contentLength} exceeds maxMessageBytes ${this.maxMessageBytes}`);
+        }
+        const bodyStart = sep + 4;
+        const bodyEnd = bodyStart + contentLength;
+        if (this.buf.length < bodyEnd)
+            return undefined;
+        const body = this.buf.subarray(bodyStart, bodyEnd);
+        this.buf = this.buf.subarray(bodyEnd);
+        let value;
+        try {
+            value = JSON.parse(body.toString("utf8"));
+        }
+        catch {
+            throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "LSP message body is not valid JSON");
+        }
+        return value;
+    }
+}
+function indexOfHeaderSep(buf) {
+    for (let i = 0; i + 3 < buf.length; i++) {
+        if (buf[i] === 0x0d && buf[i + 1] === 0x0a && buf[i + 2] === 0x0d && buf[i + 3] === 0x0a) {
+            return i;
+        }
+    }
+    return -1;
+}
+function parseContentLength(headerText) {
+    const lines = headerText.split("\r\n");
+    let contentLength;
+    for (const line of lines) {
+        if (line.length === 0)
+            continue;
+        const colon = line.indexOf(":");
+        if (colon <= 0) {
+            throw new LspFrameError("ERR_PRISM_LSP_FRAMING", `Malformed LSP header line: ${line}`);
+        }
+        const name = line.slice(0, colon).trim().toLowerCase();
+        const value = line.slice(colon + 1).trim();
+        if (name === "content-length") {
+            if (!/^\d+$/.test(value)) {
+                throw new LspFrameError("ERR_PRISM_LSP_FRAMING", `Invalid Content-Length: ${value}`);
+            }
+            if (contentLength !== undefined) {
+                throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "Duplicate Content-Length header");
+            }
+            contentLength = Number(value);
+            if (!Number.isSafeInteger(contentLength) || contentLength < 0) {
+                throw new LspFrameError("ERR_PRISM_LSP_FRAMING", `Invalid Content-Length: ${value}`);
+            }
+        }
+        // Content-Type and other headers ignored; reject CR/LF injection already split by lines.
+    }
+    if (contentLength === undefined) {
+        throw new LspFrameError("ERR_PRISM_LSP_FRAMING", "Missing Content-Length header");
+    }
+    return contentLength;
+}
+//# sourceMappingURL=framing.js.map

package/dist/language/index.d.ts

@@ -0,0 +1,4 @@
+export { encodeLspFrame, LspFrameError, LspFrameReader } from "./framing.js";
+export { LspClient } from "./client.js";
+export { applyTextEdits, createLanguageIntelligence, LanguageIntelligenceError, resolveLanguageIntelligenceLimits, } from "./intelligence.js";
+export type { CreateLanguageIntelligenceOptions, LanguageDiagnostic, LanguageIntelligence, LanguageIntelligenceLimits, LanguageLocation, LanguageServerSpec, LanguageSymbol, LanguageTextEdit, LanguageWorkspaceEdit, } from "./types.js";

package/dist/language/index.js

@@ -0,0 +1,4 @@
+export { encodeLspFrame, LspFrameError, LspFrameReader } from "./framing.js";
+export { LspClient } from "./client.js";
+export { applyTextEdits, createLanguageIntelligence, LanguageIntelligenceError, resolveLanguageIntelligenceLimits, } from "./intelligence.js";
+//# sourceMappingURL=index.js.map

package/dist/language/intelligence.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Host-selected language intelligence over one bounded in-package LSP client.
+ * Servers spawn only on first use; URIs confined to workspaceRoot; renames gated by ExecutionPolicy.
+ */
+import { type CreateLanguageIntelligenceOptions, type LanguageIntelligence, type LanguageTextEdit } from "./types.js";
+export declare function createLanguageIntelligence(options: CreateLanguageIntelligenceOptions): LanguageIntelligence;
+/** Apply LSP text edits (0-based line/character) from end to start. */
+export declare function applyTextEdits(content: string, edits: readonly LanguageTextEdit[]): string;
+export type { CreateLanguageIntelligenceOptions, LanguageDiagnostic, LanguageIntelligence, LanguageIntelligenceLimits, LanguageLocation, LanguageServerSpec, LanguageSymbol, LanguageTextEdit, LanguageWorkspaceEdit, } from "./types.js";
+export { LanguageIntelligenceError, resolveLanguageIntelligenceLimits } from "./types.js";