teapot-coding-agent 0.37.58 → 0.37.60

package/dist/acp/adapter.js

@@ -1,29 +1,12 @@
 import { readEvents } from "../log/events.js";
 import path from "node:path";
 export const ACP_PROTOCOL_VERSION = 1;
-/**
- * How often a running turn is drained for new events.
- *
- * ACP has no push channel, so the turn is streamed by polling the agent's own
- * log. 150ms is well under the ~60ms render tick a human notices, and the read is
- * a tail of a file this process is already appending to.
- */
 const STREAM_POLL_MS = 150;
 const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-/** JSON-RPC error codes we use (the standard set plus JSON-RPC's own). */
 const PARSE_ERROR = -32700;
 const METHOD_NOT_FOUND = -32601;
 const INVALID_PARAMS = -32602;
 const INTERNAL_ERROR = -32603;
-/* ---------- streaming: log events → session/update notifications ---------- */
-/**
- * ACP `ToolCall.kind` for a teapot tool name.
- *
- * The schema's own enum (verified against schema/v1/schema.json):
- * read, edit, delete, move, search, execute, fetch, think, switch_mode, other,
- * description. Editors use this to pick an icon and to decide whether the call
- * mutates anything, so mapping our tools onto it is worth doing properly.
- */
 const TOOL_KINDS = {
     read_file: "read",
     list_dir: "read",
@@ -40,7 +23,6 @@ const TOOL_KINDS = {
     memory: "edit",
     get_memory: "read",
 };
-/** Filesystem tools whose `path` argument is worth surfacing as a location. */
 const LOCATED_TOOLS = new Set([
     "read_file",
     "edit_file",
@@ -49,7 +31,6 @@ const LOCATED_TOOLS = new Set([
     "file_edit",
     "list_dir",
 ]);
-/** a one-line title for a tool call, the way an editor shows it in a list */
 function toolTitle(name, args) {
     const first = (k) => {
         const v = args[k];
@@ -61,7 +42,6 @@ function toolTitle(name, args) {
         return first("pattern") ? `grep /${first("pattern")}/` : "grep";
     return first("path") ?? name;
 }
-/** Absolute path for a tool's location, so an editor can open the file. */
 function toolLocation(name, args, workspace) {
     if (!LOCATED_TOOLS.has(name))
         return [];
@@ -72,19 +52,10 @@ function toolLocation(name, args, workspace) {
     const line = Number(args.line ?? args.line_number ?? NaN);
     return [{ path: abs, ...(Number.isFinite(line) && line > 0 ? { line } : {}) }];
 }
-/**
- * Turn one logged event into the session/update payload for it, or null when the
- * event has no ACP equivalent (and must therefore NOT be invented into one).
- *
- * Exported so the mapping is testable without a transport.
- */
 export function updateForEvent(e, opts) {
     const d = (e.data ?? {});
     switch (e.type) {
         case "message": {
-            // The completion AUDIT's verdict and the operator-facing summary are
-            // timeline content, not something the agent said to the model; an editor
-            // must not be shown an agent speaking a harness message.
             if (d.final === true || d.operatorFacing === true)
                 return null;
             const text = String(d.content ?? "");
@@ -124,9 +95,6 @@ export function updateForEvent(e, opts) {
             };
         }
         default:
-            // state transitions, goals, todos, compactions, notes: all internal. The
-            // schema HAS update kinds for some of this (plan, usage_update), but
-            // emitting them with guessed payloads would be worse than silence.
             return null;
     }
 }
@@ -136,9 +104,7 @@ export class AcpAdapter {
     output;
     defaultCwd;
     sessions = new Map();
-    /** id -> notification params, so a prompt turn can stream updates */
     turnUpdates = new Map();
-    /** sessions cancelled during the CURRENT turn, cleared when it starts (#15) */
     cancelled = new Set();
     buffer = "";
     nextSession = 1;
@@ -149,7 +115,6 @@ export class AcpAdapter {
         this.output = opts.output ?? process.stdout;
         this.defaultCwd = opts.defaultCwd ?? process.cwd();
     }
-    /** Attach to the stream. Resolves when stdin ends. */
     listen() {
         return new Promise((resolve) => {
             this.input.on("data", (chunk) => this.onData(String(chunk)));
@@ -159,10 +124,8 @@ export class AcpAdapter {
                 this.input.resume();
         });
     }
-    /* ---------- transport ---------- */
     onData(chunk) {
         this.buffer += chunk;
-        // NDJSON: one JSON object per line
         let nl;
         while ((nl = this.buffer.indexOf("\n")) >= 0) {
             const line = this.buffer.slice(0, nl).trim();
@@ -177,7 +140,6 @@ export class AcpAdapter {
             msg = JSON.parse(line);
         }
         catch {
-            // a parse error has no id to answer
             this.send({ jsonrpc: "2.0", id: null, error: { code: PARSE_ERROR, message: "invalid JSON" } });
             return;
         }
@@ -195,7 +157,6 @@ export class AcpAdapter {
     fail(id, code, message) {
         this.send({ jsonrpc: "2.0", id, error: { code, message } });
     }
-    /* ---------- dispatch ---------- */
     async dispatch(msg) {
         const { method, id, params } = msg;
         const isNotification = id === undefined || id === null;
@@ -217,7 +178,6 @@ export class AcpAdapter {
                         return this.ok(id ?? null, {});
                     return;
                 default:
-                    // notifications for unknown methods get NO response at all
                     if (isNotification)
                         return;
                     return this.fail(id ?? null, METHOD_NOT_FOUND, `unknown method: ${method}`);
@@ -225,7 +185,7 @@ export class AcpAdapter {
         }
         catch (err) {
             if (isNotification)
-                return; // never answer a notification
+                return;
             return this.fail(id ?? null, INTERNAL_ERROR, err.message);
         }
     }
@@ -233,13 +193,10 @@ export class AcpAdapter {
         this.initialized = true;
         return {
             protocolVersion: ACP_PROTOCOL_VERSION,
-            // Only capabilities we actually implement: a client calls what we
-            // advertise, so a partial implementation would be worse than omission.
             agentCapabilities: { loadSession: true, promptCapabilities: { image: false, audio: false } },
             authMethods: [],
         };
     }
-    /* ---------- sessions ---------- */
     async newSession(params) {
         const p = (params ?? {});
         const cwd = p.cwd ? path.resolve(String(p.cwd)) : this.defaultCwd;
@@ -253,9 +210,8 @@ export class AcpAdapter {
         const id = String(p.sessionId ?? "");
         const existing = this.sessions.get(id);
         if (existing)
-            return null; // already live
+            return null;
         const cwd = p.cwd ? path.resolve(String(p.cwd)) : this.defaultCwd;
-        // resuming means the agent's own log is restored, not a fresh session
         const agent = await this.master.addAgent({ id, workspace: cwd }, { persist: false, fresh: false });
         this.sessions.set(id, { id, cwd, agent });
         return null;
@@ -265,12 +221,9 @@ export class AcpAdapter {
         const s = p.sessionId ? this.sessions.get(String(p.sessionId)) : undefined;
         if (!s)
             return;
-        // The Agent's own "stopped" flag is private, and this adapter is the
-        // component that answered the cancel notification anyway.
         this.cancelled.add(s.id);
         s.agent.stop("cancelled via ACP");
     }
-    /* ---------- prompt turn ---------- */
     async prompt(id, params) {
         const p = (params ?? {});
         const s = p.sessionId ? this.sessions.get(String(p.sessionId)) : undefined;
@@ -283,8 +236,7 @@ export class AcpAdapter {
         if (!text)
             return this.fail(id, INVALID_PARAMS, "prompt must contain text");
         this.turnUpdates.set(id, { sessionId: s.id });
-        this.cancelled.delete(s.id); // a cancel is per-turn, not per-session
-        // Without streaming, the client sees NOTHING until the whole turn finishes.
+        this.cancelled.delete(s.id);
         const abort = new AbortController();
         const stream = this.streamTurn(s.id, abort.signal).catch(() => { });
         try {
@@ -292,11 +244,8 @@ export class AcpAdapter {
             if (s.agent.status !== "running")
                 s.agent.start("acp prompt");
             await s.agent.settled();
-            // One last drain, or the final tool result and closing message can be
-            // missed: `settled()` resolves the moment the agent stops, and the last
-            // append may not have landed yet.
             abort.abort();
-            await stream; // resolves after its own final drain
+            await stream;
             return this.ok(id, { stopReason: this.cancelled.has(s.id) ? "cancelled" : "end_turn" });
         }
         catch (err) {
@@ -307,7 +256,6 @@ export class AcpAdapter {
             this.turnUpdates.delete(id);
         }
     }
-    /** drain a session's log tail into session/update notifications */
     async drainOnce(sessionId, afterSeq = 0) {
         const s = this.sessions.get(sessionId);
         if (!s)
@@ -317,28 +265,13 @@ export class AcpAdapter {
             if (e.seq <= afterSeq)
                 continue;
             const update = updateForEvent(e, { workspace: s.cwd });
-            // null means "no ACP equivalent" — state flips, goals, notes
             if (update)
                 this.notify("session/update", { sessionId, update });
         }
-        // Advance past EVERY event read, emitted or not, so nothing is reconsidered
-        // on the next poll.
         return events.reduce((m, e) => Math.max(m, e.seq), afterSeq);
     }
-    /**
-     * Poll one session until it settles, streaming each batch as it appears.
-     *
-     * The JSONL log rather than the bus is deliberate: a bus listener attached at
-     * the wrong moment can miss the start of a reply, and after a crash mid-turn
-     * the file is the one complete account of what happened. It also means a
-     * resumed session replays exactly the same updates.
-     */
     async streamTurn(sessionId, signal) {
-        // Everything before this prompt belongs to earlier turns.
         let cursor = await this.logTail(sessionId);
-        // The drain happens BEFORE the abort check: a turn can finish inside one poll
-        // interval, so a loop that slept and then bailed on `signal.aborted` would
-        // exit having drained NOTHING and the editor would receive silence.
         for (;;) {
             cursor = await this.drainOnce(sessionId, cursor);
             if (signal.aborted)
@@ -346,7 +279,6 @@ export class AcpAdapter {
             await sleep(STREAM_POLL_MS);
         }
     }
-    /** highest seq currently in a session's log, or 0 */
     async logTail(sessionId) {
         const s = this.sessions.get(sessionId);
         if (!s)