@illuminis/comprism 0.1.3 → 0.1.5

package/out/executor/toolservers.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolServers = void 0;
+/**
+ * Tool servers on this machine (manual 9.10): started when a job needs one,
+ * spoken to over standard input and output, stopped when the job ends.
+ *
+ * A local helper and nothing more. Which servers exist, whether one may run
+ * in this project, whether a call is allowed and what a result means are all
+ * the service's. This starts the command the person approved, asks for the
+ * tool list, carries one call, and reports what came back or why nothing did.
+ *
+ * Only the two methods an agent needs: list the tools, call a tool.
+ */
+const child_process_1 = require("child_process");
+/** How long one request may take before it is reported as not answered. */
+const timeoutMs = () => Number(process.env.COMPRISM_TOOL_SERVER_TIMEOUT_MS || 30_000);
+/** What one result may carry back. The service cuts it again. */
+const MAX_RESULT_CHARS = 20_000;
+class Server {
+    name;
+    command;
+    proc;
+    buffer = "";
+    nextId = 1;
+    pending = new Map();
+    gone = null;
+    ready;
+    constructor(name, command, cwd) {
+        this.name = name;
+        this.command = command;
+        // The command exactly as the person approved it, through their shell, the
+        // way they would type it themselves.
+        // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process -- the tool server command exactly as the person approved it
+        this.proc = (0, child_process_1.spawn)(this.command, { cwd, shell: true, stdio: ["pipe", "pipe", "pipe"],
+            windowsHide: true });
+        this.proc.stdout.setEncoding("utf8");
+        this.proc.stdout.on("data", (chunk) => this.read(chunk));
+        this.proc.stderr.on("data", () => { });
+        this.proc.stdin.on("error", () => { });
+        this.proc.on("error", (e) => this.fail(`could not be started: ${e.message}`));
+        this.proc.on("exit", (code) => this.fail(`stopped${code === null ? "" : ` (exit ${code})`}`));
+        this.ready = this.request("initialize", {
+            protocolVersion: "2025-06-18", capabilities: {},
+            clientInfo: { name: "comprism", version: "1" },
+        }).then(() => { this.notify("notifications/initialized"); });
+        this.ready.catch(() => { });
+    }
+    fail(why) {
+        if (this.gone)
+            return;
+        this.gone = `The tool server ${this.name} ${why}.`;
+        for (const [, p] of this.pending) {
+            clearTimeout(p.timer);
+            p.reject(new Error(this.gone));
+        }
+        this.pending.clear();
+    }
+    read(chunk) {
+        this.buffer += chunk;
+        let at;
+        while ((at = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, at).trim();
+            this.buffer = this.buffer.slice(at + 1);
+            if (!line)
+                continue;
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                // A reply that is not a reply: every waiting request is told so.
+                for (const [id, p] of this.pending) {
+                    clearTimeout(p.timer);
+                    p.reject(new Error(`The tool server ${this.name} sent something that is not a reply.`));
+                    this.pending.delete(id);
+                }
+                continue;
+            }
+            const id = typeof msg.id === "number" ? msg.id : Number(msg.id);
+            const waiting = this.pending.get(id);
+            if (!waiting)
+                continue;
+            clearTimeout(waiting.timer);
+            this.pending.delete(id);
+            if (msg.error) {
+                const e = msg.error;
+                waiting.reject(new Error(`The tool server ${this.name} refused: ${e.message ?? "an error"}.`));
+            }
+            else {
+                waiting.resolve((msg.result ?? {}));
+            }
+        }
+    }
+    notify(method) {
+        if (this.gone)
+            return;
+        this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", method }) + "\n");
+    }
+    request(method, params) {
+        if (this.gone)
+            return Promise.reject(new Error(this.gone));
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`The tool server ${this.name} did not answer within ${Math.max(1, Math.round(timeoutMs() / 1000))} seconds.`));
+            }, timeoutMs());
+            this.pending.set(id, { resolve, reject, timer });
+            this.proc.stdin.write(JSON.stringify({ jsonrpc: "2.0", id, method, params }) + "\n");
+        });
+    }
+    stop() {
+        this.fail("was stopped");
+        try {
+            this.proc.stdin.end();
+        }
+        catch { /* already closed */ }
+        // On Windows the command runs under cmd.exe, and ending cmd.exe leaves
+        // the server itself running. The whole tree is ended instead, so nothing
+        // outlives the job (manual 9.10).
+        if (process.platform === "win32" && this.proc.pid && this.proc.exitCode === null) {
+            try {
+                (0, child_process_1.spawnSync)("taskkill", ["/pid", String(this.proc.pid), "/T", "/F"], { windowsHide: true, stdio: "ignore" });
+                return;
+            }
+            catch { /* fall through to the ordinary stop */ }
+        }
+        try {
+            this.proc.kill();
+        }
+        catch { /* already gone */ }
+    }
+}
+/** The tool servers one job started, by name. */
+class ToolServers {
+    cwd;
+    running = new Map();
+    constructor(cwd) {
+        this.cwd = cwd;
+    }
+    async server(name, command) {
+        let s = this.running.get(name);
+        if (!s || s.command !== command) {
+            s?.stop();
+            s = new Server(name, command, this.cwd);
+            this.running.set(name, s);
+        }
+        await s.ready;
+        return s;
+    }
+    /** The server's tools, as it described them, as JSON text. */
+    async list(name, command) {
+        try {
+            const s = await this.server(name, command);
+            const r = await s.request("tools/list", {});
+            if (!Array.isArray(r.tools)) {
+                return { isError: true, content: `The tool server ${name} sent something that is not a tool list.` };
+            }
+            return { isError: false, content: JSON.stringify(r.tools) };
+        }
+        catch (e) {
+            this.running.get(name)?.stop();
+            this.running.delete(name);
+            return { isError: true, content: e.message };
+        }
+    }
+    /** One call, and the text the server returned. */
+    async call(name, command, tool, args) {
+        try {
+            const s = await this.server(name, command);
+            const r = await s.request("tools/call", { name: tool, arguments: args ?? {} });
+            const blocks = Array.isArray(r.content) ? r.content : [];
+            const text = blocks.filter((b) => b.type === "text").map((b) => String(b.text ?? "")).join("\n").trim();
+            return { isError: r.isError === true, content: (text || "(the tool returned nothing)").slice(0, MAX_RESULT_CHARS) };
+        }
+        catch (e) {
+            return { isError: true, content: e.message };
+        }
+    }
+    /** Every server this job started, stopped. Called when the job ends. */
+    stopAll() {
+        for (const [, s] of this.running)
+            s.stop();
+        this.running.clear();
+    }
+    get count() { return this.running.size; }
+}
+exports.ToolServers = ToolServers;

package/out/executor/worktree.d.ts

@@ -0,0 +1,9 @@
+import { RunResult, ShellOptions } from "./shell";
+/** Where a copy is, by its id, or undefined. */
+export declare function worktreePath(id: string): string | undefined;
+export declare function openWorktree(id: string, opts: ShellOptions): Promise<RunResult>;
+/** What the helper changed in its copy, as one diff. */
+export declare function diffWorktree(id: string, opts: ShellOptions): Promise<RunResult>;
+export declare function closeWorktree(id: string, opts: ShellOptions): Promise<RunResult>;
+/** Every copy this process made, removed; for the end of a session. */
+export declare function closeAllWorktrees(root: string): Promise<void>;

package/out/executor/worktree.js

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.worktreePath = worktreePath;
+exports.openWorktree = openWorktree;
+exports.diffWorktree = diffWorktree;
+exports.closeWorktree = closeWorktree;
+exports.closeAllWorktrees = closeAllWorktrees;
+/**
+ * A helper's own copy of the project (manual 5.26).
+ *
+ * A git worktree in the temporary folder, started from the project as it is
+ * now: the last commit plus the person's uncommitted changes to tracked files,
+ * committed inside the copy as its starting point. The helper's edits land
+ * there and nowhere else; what comes back is a diff against that starting
+ * point, which the service applies to the real folder with the usual approval.
+ * Nothing here decides anything: it makes the copy, reads its diff, and
+ * removes it.
+ */
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const shell_1 = require("./shell");
+const copies = new Map();
+const git = (args, opts) => (0, shell_1.runProgram)("git", args, opts);
+const okExit = (r) => !r.isError && /^exit 0/.test(r.content);
+const body = (r) => r.content.replace(/^exit -?\d+\n\n/, "");
+/** Where a copy is, by its id, or undefined. */
+function worktreePath(id) {
+    return copies.get(id);
+}
+async function openWorktree(id, opts) {
+    if (!/^[\w-]{1,40}$/.test(id))
+        return { isError: true, content: "Refused: not a usable copy name." };
+    if (copies.has(id))
+        return { content: copies.get(id), summary: `copy ${id}` };
+    const where = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), `comprism-helper-${id}-`));
+    fs.rmdirSync(where);
+    const made = await git(["worktree", "add", "--detach", "-q", where, "HEAD"], opts);
+    if (!okExit(made))
+        return { isError: true, content: `A separate copy could not be made: ${body(made)}` };
+    const inCopy = { ...opts, root: where, cwd: undefined };
+    // The person's uncommitted changes, so the helper starts from what they see.
+    const pending = await git(["diff", "--binary", "HEAD"], opts);
+    const patch = body(pending);
+    if (okExit(pending) && patch.trim() && patch.trim() !== "(no output)") {
+        const file = path.join(where, ".comprism-start.patch");
+        fs.writeFileSync(file, patch.endsWith("\n") ? patch : `${patch}\n`);
+        await git(["apply", "--whitespace=nowarn", file], inCopy);
+        fs.unlinkSync(file);
+    }
+    await git(["add", "-A"], inCopy);
+    await git(["-c", "user.name=comprism", "-c", "user.email=helper@illuminis.ai",
+        "commit", "-q", "--allow-empty", "--no-verify", "-m", "start"], inCopy);
+    copies.set(id, fs.realpathSync(where));
+    return { content: copies.get(id), summary: `copy ${id}` };
+}
+/** What the helper changed in its copy, as one diff. */
+async function diffWorktree(id, opts) {
+    const where = copies.get(id);
+    if (!where)
+        return { isError: true, content: `There is no copy called ${id}.` };
+    const inCopy = { ...opts, root: where, cwd: undefined };
+    await git(["add", "-A"], inCopy);
+    const d = await git(["--no-pager", "diff", "--cached", "--binary", "--no-color", "HEAD"], inCopy);
+    if (!okExit(d))
+        return { isError: true, content: body(d) };
+    const text = body(d).trim() === "(no output)" ? "" : body(d);
+    return { content: text, summary: text ? "changes" : "no changes", facts: { changed: text ? 1 : 0 } };
+}
+async function closeWorktree(id, opts) {
+    const where = copies.get(id);
+    if (!where)
+        return { content: `${id} is already gone.` };
+    await git(["worktree", "remove", "--force", where], opts);
+    try {
+        fs.rmSync(where, { recursive: true, force: true });
+    }
+    catch { /* removed above */ }
+    copies.delete(id);
+    return { content: `Removed ${id}.` };
+}
+/** Every copy this process made, removed; for the end of a session. */
+async function closeAllWorktrees(root) {
+    for (const id of [...copies.keys()])
+        await closeWorktree(id, { root });
+}

package/out/graph/read-python.js

@@ -51,9 +51,10 @@ const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
+const self_1 = require("../lib/self");
 /** The reader script, beside the built code in both a checkout and an install. */
 function scriptPath() {
-    return path.resolve(__dirname, "..", "..", "scripts", "read_python.py");
+    return (0, self_1.shippedFile)("read_python.py", path.resolve(__dirname, "..", "..", "scripts", "read_python.py"));
 }
 let interpreter;
 /** Which Python this machine has, or null. Asked once per process. */

package/out/lib/attach.d.ts

@@ -9,13 +9,27 @@ export interface Attached {
     /** The text was longer than one turn can carry and was cut. */
     truncated: boolean;
     isImage: boolean;
+    /** Bytes on disk, which the job record keeps (manual 3.11). */
+    sizeBytes: number;
+    /** What the service says about the file after its name, worded by the
+     *  service so every client shows the same line (manual 3.1 and 3.6). */
+    summary: string;
+}
+/** Why one named file was left out, in the service's fixed list (manual 3.10). */
+export interface Problem {
+    code: string;
+    message: string;
 }
 /** A path somebody named, before anything has been read. */
 export interface Mention {
     /** Exactly as it appeared, so it can be taken back out of the sentence. */
     raw: string;
-    /** Resolved, unescaped and known to exist. */
+    /** Resolved and unescaped. */
     file: string;
+    /** As the person wrote it, unescaped, for the messages they read. */
+    shown: string;
+    /** Set when the file cannot be attached; nothing is sent for it. */
+    problem?: Problem;
 }
 /**
  * Take the shell's escaping back off a path.
@@ -23,17 +37,32 @@ export interface Mention {
  * A dragged file arrives as `/Users/me/My\ Report.pdf`, and a pasted one is
  * often in quotes. Both are the shell's way of saying "this is one thing", and
  * neither is part of the name.
+ *
+ * On Windows a backslash is the folder separator and never an escape: its
+ * terminals quote a dragged path instead. Stripping backslashes there turned
+ * `C:\Users\me\notes.txt` into `C:Usersmenotes.txt`, which was the Windows
+ * failure found in prompt 01.
+ */
+export declare function unescapePath(token: string, platform?: string): string;
+/**
+ * What stops a file being attached, checked on this machine before anything is
+ * sent (manual 3.10). Only the four facts the service cannot see: whether the
+ * file is there, is a folder, can be read, or is a link to nothing.
  */
-export declare function unescapePath(token: string): string;
+export declare function localProblem(file: string, shown: string): Problem | undefined;
 /**
  * Every file the typed line points at, in the order they were named.
  *
- * A token that looks like a path but is not on the disk is left alone and stays
- * part of the question. Somebody writing about a path they plan to create is
- * doing something perfectly ordinary, and refusing their line over it would be
- * the tool arguing with them.
+ * Anything after an `@` is a request to attach, so a problem with it is
+ * reported. Any other path (absolute, `~/`, `./`, `../`, quoted) that is not a
+ * readable file is left alone and stays part of the question: somebody writing
+ * about a path they plan to create, or a folder they want looked at, is doing
+ * something perfectly ordinary.
  */
-export declare function mentions(line: string, cwd: string): Mention[];
+export declare function mentions(line: string, root: string, here?: string, platform?: string): Mention[];
+/** The line begins with an absolute path to something on the disk, as a
+ *  dragged file does, rather than with a slashed command word. */
+export declare function startsWithPath(line: string, platform?: string): boolean;
 /**
  * The question with the long paths taken out and the file names left in.
  *
@@ -43,20 +72,35 @@ export declare function mentions(line: string, cwd: string): Mention[];
  * nothing but a place for the model to try to open something it cannot reach.
  */
 export declare function withoutPaths(line: string, found: Mention[]): string;
+/** The line with every mention taken out: empty when it named files and said
+ *  nothing else, which is a drag and drop waiting for its question. */
+export declare function withoutMentions(line: string, found: Mention[]): string;
 /**
  * Hand the files to the server and get back the ids the question will carry.
  *
  * One at a time and in order, because the caps are per file and a refusal names
- * which file it is refusing. A file that cannot be read does not stop the
- * others: the person gets their answer about the four that worked, and is told
- * plainly about the one that did not.
+ * which file it is refusing. The service is asked first, by name and size, so a
+ * program file or a file over the limit is refused before a byte of it moves.
+ * A file that cannot be read does not stop the others.
  */
 export declare function upload(baseUrl: string, credential: string, files: string[]): Promise<{
     attached: Attached[];
     refused: {
         file: string;
         why: string;
+        code?: string;
     }[];
 }>;
-/** What was attached, in one line each, for the person to see before it runs. */
-export declare function describe(a: Attached): string;
+/** One `attached` line per file, names in a column, as manual 3.1 shows. */
+export declare function describe(items: Attached[]): string[];
+/** The waiting list, numbered for `detach N` (manual 3.6). */
+export declare function listing(items: Attached[]): string[];
+/**
+ * File names from the project for Tab after `@` (manual 3.1).
+ *
+ * A bounded walk, because a completion that takes a second is one nobody uses.
+ */
+export declare function projectFiles(root: string, limit?: number): string[];
+/** What Tab completes the line to, in readline's shape: the choices, and the
+ *  part of the line they replace. */
+export declare function completeAt(line: string, files: () => string[]): [string[], string];