@illuminis/comprism 0.1.2 → 0.1.4

package/out/agent/command.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AGENT_HELP = void 0;
+exports.AGENT_HELP = exports.MODES = void 0;
 exports.runAgent = runAgent;
 /**
  * `comprism work` — the coding agent, from a terminal.
@@ -56,8 +56,11 @@ exports.runAgent = runAgent;
 const fs = __importStar(require("fs"));
 const readline = __importStar(require("readline"));
 const connection_1 = require("../lib/connection");
+const project_1 = require("../lib/project");
 const session_1 = require("./session");
 const ui = __importStar(require("./render"));
+const output_1 = require("../lib/output");
+const self_1 = require("../lib/self");
 /** The WebSocket the session needs is a global from Node 22.
  *
  *  Checked here with a message somebody can act on. Without it the failure is
@@ -70,7 +73,7 @@ function requireWebSocket() {
         ui.dim(`  You are on ${process.version}. Upgrade Node and try again.\n`));
     return false;
 }
-const MODES = ["read_only", "approve_writes", "auto_edit", "full_auto"];
+exports.MODES = ["read_only", "approve_writes", "auto_edit", "full_auto"];
 /**
  * Start a job, hand the terminal back, and keep working.
  *
@@ -105,28 +108,83 @@ async function runDetached(args) {
     const log = fs.openSync(logPath, "a");
     // Detached, with its own process group, so closing the terminal does not take
     // the job with it. `unref` is what actually lets this process exit.
-    const child = spawn(process.execPath, [
-        process.argv[1] ?? "", "agent",
+    const child = spawn(...(0, self_1.selfLaunch)([
+        "agent",
         ...args.request,
         "--mode", mode, "--yes",
         ...(args.model ? ["--model", args.model] : []),
         ...(args.pin ? ["--pin"] : []),
         ...(args.maxSpend ? ["--max-spend", String(args.maxSpend)] : []),
+        ...(args.timeout ? ["--timeout", String(args.timeout)] : []),
         ...(args.allow ?? []).flatMap((c) => ["--allow", c]),
         ...(args.cwd ? ["--cwd", args.cwd] : []),
-    ], { detached: true, stdio: ["ignore", log, log], env: { ...process.env, NO_COLOR: "1" } });
+        ...(args.addFolders ?? []).flatMap((f) => ["--add-folder", f]),
+    ]), {
+        detached: true, stdio: ["ignore", log, log],
+        // Marked, so the job is recorded as a background job and its log can be
+        // found again by `comprism jobs attach` (manual 5.14).
+        env: { ...process.env, NO_COLOR: "1", COMPRISM_BACKGROUND: "1", COMPRISM_JOB_LOG: logPath },
+    });
     child.unref();
     process.stdout.write(ui.green(`  Started in the background as process ${child.pid}.\n`)
+        + ui.dim("  comprism jobs lists it; comprism jobs attach <job> watches it.\n")
         + ui.dim(`  Follow it:  tail -f ${logPath}\n`)
         + ui.dim("  It keeps working while you do something else. This machine has "
             + "to stay awake: the files are here, so the work is too.\n"));
     return 0;
 }
 async function runAgent(args) {
+    const output = args.output;
+    const json = output?.format === "json";
+    const streaming = output?.format === "stream";
+    // A stream is lines the service built, printed as they come (manual 10.4).
+    // If the program reading it goes away, the job is stopped and the exit is
+    // 141, with nothing said about it.
+    let pipeClosed = false;
+    let finishedLine = false;
+    let stopJob = null;
+    const emit = (items) => {
+        for (const item of items) {
+            if (pipeClosed)
+                return;
+            if (item.event === "job_finished")
+                finishedLine = true;
+            process.stdout.write(JSON.stringify(item) + "\n");
+        }
+    };
+    if (streaming) {
+        process.stdout.on("error", (e) => {
+            if (e.code !== "EPIPE")
+                return;
+            pipeClosed = true;
+            stopJob?.();
+        });
+    }
+    /** An ending the service never saw: its number, and with --output json the
+     *  result object in its published shape (manual 10.3, Appendix B). */
+    const ended = (reason, why) => {
+        if (json)
+            (0, output_1.printJson)((0, output_1.localResult)(reason, why));
+        if (streaming)
+            emit([{ event: "job_finished", ...(0, output_1.localResult)(reason, why) }]);
+        return (0, output_1.exitFor)(reason);
+    };
+    // A folder that does not exist is refused before anything runs or is charged
+    // (manual 2.1, exit 2 in Appendix B).
+    const folders = [];
+    for (const raw of [args.cwd ?? process.cwd(), ...(args.addFolders ?? [])]) {
+        const found = (0, project_1.checkFolder)(raw);
+        if (!found.ok) {
+            process.stderr.write(ui.red(`  ${found.why}`) + ui.dim("  Nothing ran and nothing was charged.\n"));
+            return 2;
+        }
+        folders.push(found.path);
+    }
+    const [startFolder, ...added] = folders;
     if (!requireWebSocket())
         return 1;
     if (args.background)
-        return runDetached(args);
+        return runDetached({ ...args, cwd: startFolder, addFolders: added });
     const connection = (0, connection_1.readConnection)();
     if (!connection?.url) {
         process.stderr.write(
@@ -135,7 +193,7 @@ async function runAgent(args) {
         // brand new user is given was a dead end.
         ui.red("  Not signed in.") +
             ui.dim("  Run `comprism login` first.\n"));
-        return 1;
+        return ended("signed_out", "Not signed in. Run comprism login first.");
     }
     // The machine credential, not the session token. The session token belongs to
     // a browser sign-in and is short lived; this is the long-lived credential
@@ -146,14 +204,28 @@ async function runAgent(args) {
     if (!credential) {
         process.stderr.write(ui.red("  This machine has no workspace key.") +
             ui.dim("  Run `comprism connect` again to mint one.\n"));
-        return 1;
+        return ended("signed_out", "This machine has no workspace key. Run comprism connect again.");
     }
-    const root = fs.realpathSync(args.cwd ?? process.cwd());
-    const mode = args.mode ?? "approve_writes";
-    if (!MODES.includes(mode)) {
+    const project = (0, project_1.resolveProject)(startFolder, added);
+    const root = project.root;
+    // Absent means the settings decide (manual 2.10): the service resolves the
+    // mode from the local and project settings files and your account.
+    const mode = args.mode;
+    if (mode !== undefined && !exports.MODES.includes(mode)) {
         process.stderr.write(ui.red(`  ${mode} is not a permission mode.`) +
-            ui.dim(`  One of: ${MODES.join(", ")}\n`));
-        return 1;
+            ui.dim(`  One of: ${exports.MODES.join(", ")}\n`));
+        return ended("usage", `${mode} is not a permission mode.`);
+    }
+    // `--sandbox` never runs without one (manual 4.12): refused before anything
+    // runs or is charged.
+    if (args.sandbox) {
+        const { availability } = await Promise.resolve().then(() => __importStar(require("../executor/sandbox")));
+        const found = availability();
+        if (!found.system) {
+            process.stderr.write(ui.red(`  --sandbox cannot start: ${found.why}.`)
+                + ui.dim("  Nothing ran and nothing was charged.\n"));
+            return 1;
+        }
     }
     const request = args.request.join(" ").trim();
     if (!request && !args.resume) {
@@ -163,33 +235,99 @@ async function runAgent(args) {
     // Headless when asked for, and also when there is no terminal at all: piped
     // into a script, nobody is there to answer an approval, and pretending
     // otherwise would hang the pipeline until it timed out.
-    const headless = Boolean(args.yes) || !process.stdin.isTTY;
+    //
+    // Standard input that is a pipe is material, never answers (manual 3.9):
+    // questions then go to the terminal the caller opened, and with none the
+    // job is unattended.
+    const questions = process.stdin.isTTY
+        ? process.stdin : args.keyboard ?? null;
+    const headless = Boolean(args.yes) || !questions;
+    // ONE reader for the whole job when nobody lent a keyboard: it carries what
+    // is typed while the agent works, and it answers questions and approvals.
+    // Two readers on one keyboard divide the typing, so an answer also arrived
+    // as a correction to the job.
+    let steering = null;
+    let waiting = null;
+    const ownPrompt = (question) => new Promise((resolve) => {
+        process.stdout.write(`  ${question} `);
+        waiting = resolve;
+    });
+    const lent = args.confirm || headless ? {} : {
+        prompt: ownPrompt,
+        confirm: async (question) => /^y(es)?$/i.test(((await ownPrompt(question)) ?? "").trim()),
+    };
+    // With standard output going to a script, everything the job says on the
+    // way goes to standard error, and only the result goes to standard output
+    // (manual 10.2). `--quiet` drops the progress altogether.
+    const toErr = output ? (0, output_1.progressToErr)(output) : false;
+    const write = output?.quiet || streaming ? () => undefined
+        : toErr ? (s) => { process.stderr.write(s); } : (s) => { process.stdout.write(s); };
     const session = new session_1.TerminalSession({
         baseUrl: connection.url,
         credential,
         root,
+        project,
         permissionMode: mode,
         planOnly: Boolean(args.plan),
         planApproved: Boolean(args.approvePlan),
         model: args.model,
         pinModel: Boolean(args.pin),
         maxSpendUsd: args.maxSpend,
+        maxSteps: args.maxSteps,
+        maxMinutes: args.maxMinutes,
+        effort: args.effort,
+        sandbox: Boolean(args.sandbox),
+        commandTimeoutS: args.timeout,
+        issue: args.issue,
+        team: args.team,
+        review: args.review,
+        keepProcesses: Boolean(args.keepProcesses),
         approvedCommands: args.allow ?? [],
         attachmentIds: args.attachments ?? [],
+        leftOut: args.leftOut ?? [],
         headless,
         confirm: args.confirm,
+        prompt: args.prompt,
+        ...lent,
         resumeJobId: args.resume,
         continuesJob: args.continuesJob,
+        conversationId: args.conversationId,
         withoutMap: Boolean(args.noMap),
-    });
+        ...(args.answerSchema ? { answerSchema: args.answerSchema } : {}),
+        ...(args.queuedJob ? { queuedJob: args.queuedJob } : {}),
+        ...(args.settingsConfig ? { settingsConfig: args.settingsConfig } : {}),
+        noPersonal: Boolean(args.noPersonal),
+        ...(streaming ? { onStream: emit } : {}),
+    }, write);
+    stopJob = () => session.cancel();
     // Ctrl+C stops the JOB, not the process. Killing the process would leave the
     // job running on the server with nothing watching it, and whatever the agent
     // had started on this machine would carry on unsupervised.
-    const onInterrupt = () => session.cancel();
+    let interrupted = false;
+    const onInterrupt = () => {
+        interrupted = true;
+        // Ctrl+C at a question answers it as stopped, then stops the job.
+        const w = waiting;
+        waiting = null;
+        if (w) {
+            process.stdout.write("\n");
+            w(null);
+        }
+        session.cancel();
+    };
     process.on("SIGINT", onInterrupt);
+    session.full = Boolean(args.fullView);
     args.onStarted?.({
         cancel: () => session.cancel(),
         steer: (text) => session.steer(text),
+        pause: () => session.pause(),
+        carryOn: (text) => session.carryOn(text),
+        isPaused: () => session.paused,
+        queue: (clear) => session.queue(clear),
+        setFull: (on) => { session.full = on; },
+        jobId: () => session.jobId,
+        helpers: () => [...session.helpers.values()],
+        stopHelper: (id) => session.stopHelper(id),
     });
     // Anything typed while it works. Not a prompt, deliberately: the run is
     // printing, and a prompt competing with it for the same lines is unreadable.
@@ -198,10 +336,15 @@ async function runAgent(args) {
     // `confirm` is that one component owns the terminal; opening a reader here as
     // well would put the same two owners back on it by another door, and the
     // caller is the one already reading what gets typed.
-    let steering = null;
     if (!headless && !args.confirm) {
-        steering = readline.createInterface({ input: process.stdin, terminal: false });
+        steering = readline.createInterface({ input: questions, terminal: false });
         steering.on("line", (line) => {
+            const w = waiting;
+            if (w) {
+                waiting = null;
+                w(line);
+                return;
+            }
             const text = line.trim();
             if (text)
                 session.steer(text);
@@ -210,14 +353,54 @@ async function runAgent(args) {
     try {
         const result = await session.run(request);
         args.onFinished?.(result);
-        // A shell needs to know whether it worked. Anything other than finishing
-        // cleanly is a non-zero exit, so `comprism work ... && next-thing` behaves
-        // the way a person expects.
-        return result.outcome === "finished" ? 0 : 1;
+        // A job on its own is its session, and it has ended (manual 7.3).
+        if (!args.keepProcesses && args.conversationId) {
+            const { review } = await Promise.resolve().then(() => __importStar(require("../commands/review")));
+            await review("session_ended", { session_id: args.conversationId }).catch(() => undefined);
+        }
+        // How it ended is the service's reason word; the number comes from the
+        // table the service sent with it (manual 10.6, Appendix B). The only
+        // endings decided here are the ones the service could not see: a dropped
+        // connection with an action in doubt (8.9), Ctrl+C, and never reaching it.
+        const reason = result.outcome === "unknown" ? "unknown"
+            : interrupted ? "interrupted"
+                : result.ending?.reason ?? result.refusalReason
+                    ?? (result.outcome === "finished" ? "done" : "incomplete");
+        if (pipeClosed)
+            return (0, output_1.exitFor)("output_closed", result.exitStatus);
+        const code = (0, output_1.exitFor)(reason, result.exitStatus);
+        if (streaming) {
+            // A job refused before it started has sent no stream, so its end is
+            // the service's result for the refusal.
+            if (!finishedLine) {
+                emit([{ event: "job_finished", ...(result.result ?? (0, output_1.localResult)(reason, result.detail ?? reason)) }]);
+            }
+            if (code !== 0)
+                process.stderr.write(`  ${result.ending?.line ?? result.detail ?? reason}\n`);
+        }
+        else if (json) {
+            (0, output_1.printJson)(result.result && reason !== "unknown" && !interrupted
+                ? result.result : (0, output_1.localResult)(reason, result.detail ?? reason));
+        }
+        else if (toErr) {
+            // The final summary, and nothing else, on standard output (10.2).
+            const summary = result.ending?.line ?? result.detail ?? "";
+            if (summary)
+                process.stdout.write(`${summary}\n`);
+            if (result.text.trim() && result.text.trim() !== summary)
+                process.stdout.write(`${result.text.trim()}\n`);
+        }
+        if (code !== 0 && output?.quiet) {
+            // A number other than 0 comes with a one line reason on standard error.
+            process.stderr.write(`  ${result.ending?.line ?? result.detail ?? reason}\n`);
+        }
+        return code;
     }
     catch (err) {
+        // The live connection never opened: the service could not be reached
+        // (manual 10.14, exit 6).
         process.stderr.write(ui.red(`  ${err.message}\n`));
-        return 1;
+        return ended("unreachable", err.message);
     }
     finally {
         process.off("SIGINT", onInterrupt);
@@ -231,13 +414,15 @@ ${ui.bold("comprism work")} — a coding agent in your terminal
   comprism work "add a test for the parser and make it pass"
 
 ${ui.bold("What it does")}
-  Reads your project, changes files, runs commands and runs your tests, and
-  shows you every change before it makes it. Each step is routed to whichever
+  Reads your project, changes files, runs commands and runs your tests. It
+  shows you every change as it makes it, asks before deleting a file or
+  running a command, and can undo the whole job. Each step is routed to whichever
   model finishes the work for least, and the receipt at the end says what it
   cost.
 
 ${ui.bold("Options")}
   --mode <mode>      read_only, approve_writes (default), auto_edit, full_auto
+  --worktree <name>  work in a separate copy of the repository on its own branch
   --plan             work out what it would do and change nothing
   --approve-plan     you read the plan and want it built. Files change without
                      being asked about one at a time; commands still ask
@@ -245,12 +430,22 @@ ${ui.bold("Options")}
                      price the saving against it. It may still move you up
   --pin              run --model and nothing else, whatever it would prefer
   --max-spend <usd>  stop at this much rather than running on
+  --max-steps <n>    stop after this many steps
+  --max-minutes <n>  start no new step after this many minutes
+  --effort <level>   low, medium or high: how carefully the model thinks
+  --sandbox          run commands in the operating system's sandbox
+  --timeout <secs>   time limit for each command, two minutes unless set
+  --issue <n>        start from GitHub issue n; its text is information only
+  --team <name>      lead the team defined in .completionprism/teams/<name>.md
   --allow "<cmd>"    approve one exact command up front, repeatable. The only
                      way an unattended run can verify its own work
   --yes              never ask; anything needing approval is refused instead
   --background       start it and get your terminal back; it keeps working
   --resume <job>     carry on from a job you already started
   --cwd <path>       work in this folder rather than the current one
+  --cloud            run it on a CompletionPrism worker with a copy of the
+                     repository; comprism --resume <session> brings it back
+  --add-folder <path>  also allow this folder, repeatable
   --no-map           do not use the code map for this job; read the files
 
 ${ui.bold("While it runs")}

package/out/agent/render.d.ts

@@ -26,6 +26,11 @@ export declare const red: (t: string) => string;
 export declare const green: (t: string) => string;
 export declare const yellow: (t: string) => string;
 export declare const gray: (t: string) => string;
+/** The brand's violet, for model names and the receipt's label. */
+export declare const violet: (t: string) => string;
+/** `claude-haiku-4-5` as a person says it, `Claude Haiku 4.5`. Other vendors'
+ *  ids are shown as they arrive: a wrong guess at a name is worse than the id. */
+export declare function modelName(id: string): string;
 /** Money, at the precision a person can act on.
  *
  *  Four decimal places below a cent, because a coding step often costs less
@@ -36,6 +41,8 @@ export declare function duration(ms: number | null | undefined): string;
 /** One action, as it happens. A word as well as a color, so this still reads
  *  when piped to a file. */
 export declare function action(name: string, target: string, ok: boolean, ms?: number): string;
+/** A connected tool as people write it, `server.tool` (manual 9.10). */
+export declare function actionName(name: string): string;
 /** The share of a step's context the provider served from its cache, or null
  *  when it reported no counts. Anthropic counts cached tokens OUTSIDE the input
  *  figure, so the whole context is the three counts added together. */
@@ -44,7 +51,7 @@ export declare function reusePct(tokensIn: number | null | undefined, cacheRead:
  *  provider had already seen. The last figure is the one study 005 found
  *  missing from our receipt: without it nobody could tell a warm step from a
  *  cold one, and every step was cold. */
-export declare function step(index: number, model: string, usd: number | null, ms: number | null, reused?: number | null): string;
+export declare function step(index: number, model: string, usd: number | null, ms: number | null, reused?: number | null, reason?: string): string;
 /** The task list, reprinted whenever it changes.
  *
  *  Reprinted rather than redrawn in place: what the agent intended at each point
@@ -54,12 +61,20 @@ export declare function todos(items: Array<{
     content: string;
     status: string;
 }>): string;
+/** A question from the agent, or the plan question (manual 4.2, 4.3). The
+ *  wording is the service's; this only lays it out. */
+export declare function question(q: string, options: string[]): string;
 /** A change, before it is made.
  *
  *  Full text for a small edit and a summary for a large one. Pasting four
  *  hundred lines into a terminal is not review, it is a wall somebody presses
  *  through, and an approval people press through protects nobody. */
-export declare function diff(name: string, input: Record<string, unknown>): string;
+export declare function diff(name: string, input: Record<string, unknown>, withHead?: boolean): string;
+/** What was stopped when a session ended, one line each (manual 5.13). */
+export declare function stoppedLines(stopped: string[]): string;
+/** The first line of a finished job, as the service wrote it (manual 5.15).
+ *  Colored by its first word only; the words are the service's. */
+export declare function ending(line: string, detail: string | null | undefined): string;
 /** How the job ended, in the words a person reads. */
 export declare function outcome(o: string, detail: string | null | undefined): string;
 /** One model's share of a job, as our server reported it. */