@testchimp/cli 0.1.57 → 0.1.59

package/dist/chimphands/run.js

@@ -5,6 +5,8 @@
  */
 import { execSync, spawn } from "node:child_process";
 import { mkdirSync, openSync, writeFileSync } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
 import http from "node:http";
 import https from "node:https";
 import { URL } from "node:url";
@@ -280,6 +282,30 @@ function extractOpencodeFatalError(raw) {
     }
     return null;
 }
+/**
+ * OpenCode `message.part.delta` always sends `field: "text"` for both reasoning and
+ * answer parts. Resolve kind from partID → type learned via `message.part.updated`.
+ */
+function resolveDeltaPartKind(partId, field, partType, partTypeById) {
+    if (partType) {
+        partTypeById.set(partId, partType);
+    }
+    const known = partTypeById.get(partId);
+    if (known === "reasoning" || partType === "reasoning") {
+        partTypeById.set(partId, "reasoning");
+        return "reasoning";
+    }
+    if (known === "text" || partType === "text") {
+        partTypeById.set(partId, "text");
+        return "text";
+    }
+    // Unknown part: field is unreliable (reasoning deltas also use field "text").
+    if (field === "reasoning") {
+        partTypeById.set(partId, "reasoning");
+        return "reasoning";
+    }
+    return "text";
+}
 function parseOpencodeEvent(line) {
     try {
         return JSON.parse(line);
@@ -292,8 +318,11 @@ function parseOpencodeEvent(line) {
  * Newer OpenCode `--format json` lines often use the SSE bus shape
  * (`message.part.updated` + `properties.part`) instead of legacy `type: "text"`.
  * Normalize both into the same OpencodeEvent used by the stdout switch.
+ *
+ * `partTypeById` must be shared across lines: deltas use `field: "text"` for
+ * reasoning parts too — type comes from earlier `message.part.updated`.
  */
-function normalizeStdoutOpencodeEvent(raw) {
+function normalizeStdoutOpencodeEvent(raw, partTypeById) {
     if (!raw || typeof raw !== "object")
         return null;
     const o = raw;
@@ -312,18 +341,25 @@ function normalizeStdoutOpencodeEvent(raw) {
         const deltaProps = props;
         const part = deltaProps.part;
         if (part) {
-            const partType = part.type || deltaProps.field || "";
+            const partId = part.id || part.messageID || deltaProps.partID || "";
+            const kind = partId
+                ? resolveDeltaPartKind(partId, deltaProps.field, part.type, partTypeById)
+                : part.type === "reasoning"
+                    ? "reasoning"
+                    : "text";
             let mapped;
-            if (partType === "text")
+            if (kind === "text" || part.type === "text")
                 mapped = "text";
-            else if (partType === "reasoning")
+            else if (kind === "reasoning" || part.type === "reasoning")
                 mapped = "reasoning";
-            else if (partType === "tool")
+            else if (part.type === "tool")
                 mapped = "tool_use";
             else
                 return null;
             if (deltaProps.delta && !part.text)
                 part.text = deltaProps.delta;
+            if (mapped === "reasoning")
+                part.type = "reasoning";
             return {
                 type: mapped,
                 sessionID: part.sessionID || deltaProps.sessionID,
@@ -331,22 +367,29 @@ function normalizeStdoutOpencodeEvent(raw) {
             };
         }
         const partID = deltaProps.partID;
-        const field = deltaProps.field || "text";
         const delta = deltaProps.delta;
         if (!partID || delta == null || delta === "")
             return null;
-        if (field !== "text" && field !== "reasoning")
+        if (deltaProps.field && deltaProps.field !== "text" && deltaProps.field !== "reasoning") {
+            return null;
+        }
+        const kind = resolveDeltaPartKind(partID, deltaProps.field, undefined, partTypeById);
+        if (kind !== "text" && kind !== "reasoning")
             return null;
         return {
-            type: field === "reasoning" ? "reasoning" : "text",
+            type: kind,
             sessionID: deltaProps.sessionID,
-            part: { id: partID, type: field, text: delta },
+            part: { id: partID, type: kind, text: delta },
         };
     }
     if (type === "message.part.updated") {
         const part = props.part;
         if (!part)
             return null;
+        const partId = part.id || part.messageID;
+        if (partId && part.type) {
+            partTypeById.set(partId, part.type);
+        }
         const partType = part.type || "";
         let mapped;
         if (partType === "text")
@@ -487,6 +530,8 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
     const ac = new AbortController();
     let stopped = false;
     const textByPartId = new Map();
+    /** partID → "text" | "reasoning" | … from message.part.updated (deltas lie about field). */
+    const partTypeById = new Map();
     const directory = process.cwd();
     const sessionMatches = (sessionId) => {
         const active = callbacks.getActiveSessionId();
@@ -519,18 +564,27 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
         const ev = unwrapped;
         const type = ev.type || "";
         const props = ev.properties || {};
-        // Token stream: { partID, field, delta } — often no `part` object.
+        // Token stream: { partID, field, delta } — field is usually "text" even for reasoning.
         if (type === "message.part.delta") {
             const part = props.part;
             const partId = props.partID || part?.id || part?.messageID;
-            const field = props.field || part?.type || "text";
             const sessionId = part?.sessionID || props.sessionID;
             if (!sessionMatches(sessionId))
                 return;
             callbacks.noteSessionId(sessionId);
             if (!partId || props.delta == null || props.delta === "")
                 return;
-            if (field === "text") {
+            const kind = resolveDeltaPartKind(partId, props.field, part?.type, partTypeById);
+            if (kind === "reasoning") {
+                const key = `reasoning:${partId}`;
+                const next = (textByPartId.get(key) || "") + props.delta;
+                textByPartId.set(key, next);
+                callbacks.postEvent(ROLE_REASONING, next, liveOpts({
+                    messageId: `oc_reasoning_${partId}`,
+                }));
+                return;
+            }
+            if (kind === "text") {
                 const next = (textByPartId.get(partId) || "") + props.delta;
                 textByPartId.set(partId, next);
                 if (isTextDuplicateOfReasoning(next, reasoningBodiesFromPartMap(textByPartId))) {
@@ -539,15 +593,6 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
                 callbacks.postEvent(ROLE_ASSISTANT, next, liveOpts({
                     messageId: `oc_text_${partId}`,
                 }));
-                return;
-            }
-            if (field === "reasoning") {
-                const key = `reasoning:${partId}`;
-                const next = (textByPartId.get(key) || "") + props.delta;
-                textByPartId.set(key, next);
-                callbacks.postEvent(ROLE_REASONING, next, liveOpts({
-                    messageId: `oc_reasoning_${partId}`,
-                }));
             }
             return;
         }
@@ -559,8 +604,11 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
             if (!sessionMatches(sessionId))
                 return;
             callbacks.noteSessionId(sessionId);
+            const partId = part.id || part.messageID;
+            if (partId && part.type) {
+                partTypeById.set(partId, part.type);
+            }
             if (part.type === "text") {
-                const partId = part.id || part.messageID;
                 if (!partId)
                     return;
                 let next = part.text || "";
@@ -584,12 +632,19 @@ function startOpencodeSseRelay(attachUrl, callbacks) {
                 return;
             }
             if (part.type === "reasoning") {
-                const partId = part.id || part.messageID;
                 if (!partId)
                     return;
+                // Deltas before type was known may have been buffered under the text key.
+                const orphanText = textByPartId.get(partId);
+                if (orphanText) {
+                    textByPartId.delete(partId);
+                }
                 let next = part.text || "";
                 if (props.delta && !part.text) {
-                    next = (textByPartId.get(`reasoning:${partId}`) || "") + props.delta;
+                    next = (textByPartId.get(`reasoning:${partId}`) || orphanText || "") + props.delta;
+                }
+                else if (!next && orphanText) {
+                    next = orphanText;
                 }
                 if (part.text)
                     next = part.text;
@@ -776,9 +831,12 @@ function isAssistantEchoOfSentPrompt(assistant, ...sentPrompts) {
             continue;
         if (a === p)
             return true;
-        // Streaming echo of the (usually long) wrapped prompt: only when clearly a prefix.
+        // Streaming echo from the start of the wrapped prompt.
         if (p.length >= 64 && a.length >= 24 && p.startsWith(a))
             return true;
+        // Mid-wrap regurgitation (e.g. only the "Conversation so far:" section).
+        if (p.length >= 64 && a.length >= 40 && p.includes(a))
+            return true;
     }
     return false;
 }
@@ -1003,6 +1061,7 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         stdio: ["pipe", "pipe", "pipe"],
         env: childEnv,
     });
+    callbacks.onActiveChild?.(child);
     try {
         child.stdin?.end();
     }
@@ -1020,6 +1079,7 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         let buf = "";
         let fatalError = null;
         const textByPartId = new Map();
+        const partTypeById = new Map();
         let sawStdout = false;
         let progressTicker = setInterval(() => {
             if (sawStdout) {
@@ -1064,7 +1124,7 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
                 return;
             }
             // Newer OpenCode --format json uses bus shape (message.part.updated); normalize first.
-            const ev = normalizeStdoutOpencodeEvent(parsed) || parseOpencodeEvent(line);
+            const ev = normalizeStdoutOpencodeEvent(parsed, partTypeById) || parseOpencodeEvent(line);
             if (!ev?.type)
                 return;
             noteSessionId(ev.sessionID);
@@ -1175,6 +1235,7 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
             }
         });
         child.on("close", (code) => {
+            callbacks.onActiveChild?.(null);
             if (progressTicker) {
                 clearInterval(progressTicker);
                 progressTicker = null;
@@ -1185,6 +1246,10 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
             const stderrFatal = extractOpencodeFatalError(err);
             if (stderrFatal)
                 fatalError = stderrFatal;
+            if (callbacks.getCancelRequested?.()) {
+                resolve({ code: 0, err: "", opencodeSessionId: activeSessionId, cancelled: true });
+                return;
+            }
             if (fatalError) {
                 resolve({ code: 1, err: fatalError, opencodeSessionId: activeSessionId });
                 return;
@@ -1201,6 +1266,63 @@ function runOpencode(prompt, model, childEnv, opencodeSessionId, callbacks, atta
         });
     });
 }
+function normalizeWorktreeRelativePath(filePath) {
+    let p = String(filePath || "").trim().replace(/\\/g, "/");
+    while (p.startsWith("/"))
+        p = p.slice(1);
+    if (!p || p.includes("\0")) {
+        throw new Error("invalid path");
+    }
+    const segments = [];
+    for (const part of p.split("/")) {
+        if (!part || part === ".")
+            continue;
+        if (part === "..") {
+            if (!segments.length)
+                throw new Error("invalid path");
+            segments.pop();
+            continue;
+        }
+        segments.push(part);
+    }
+    if (!segments.length)
+        throw new Error("invalid path");
+    return segments.join("/");
+}
+async function ackWorktreeFileWrite(backend, apiKey, sessionId, requestId, ok, errorMessage) {
+    const body = {
+        sessionId,
+        requestId,
+        ok,
+    };
+    if (errorMessage)
+        body.errorMessage = errorMessage.slice(0, 2000);
+    await postJson(backend, apiKey, "/api/chimphands/ack_worktree_file_write", body).catch((err) => {
+        console.error(`ChimpHands ack_worktree_file_write failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+}
+async function applyUserFileEdit(backend, apiKey, sessionId, edit, turnActive) {
+    if (turnActive()) {
+        await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, false, "agent turn in progress");
+        return;
+    }
+    try {
+        const relative = normalizeWorktreeRelativePath(edit.path);
+        const root = process.cwd();
+        const full = path.resolve(root, relative);
+        const rootResolved = path.resolve(root);
+        if (full !== rootResolved && !full.startsWith(rootResolved + path.sep)) {
+            throw new Error("path outside worktree");
+        }
+        await fs.mkdir(path.dirname(full), { recursive: true });
+        await fs.writeFile(full, edit.content, "utf8");
+        await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, true);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        await ackWorktreeFileWrite(backend, apiKey, sessionId, edit.requestId, false, msg);
+    }
+}
 function connectInboundStream(backend, apiKey, sessionId, handlers) {
     const url = new URL(`${backend}/api/chimphands/sessions/${encodeURIComponent(sessionId)}/inbound`);
     const lib = url.protocol === "https:" ? https : http;
@@ -1248,6 +1370,37 @@ function connectInboundStream(backend, apiKey, sessionId, handlers) {
                         if (eventName === "idle") {
                             handlers.onIdle();
                         }
+                        else if (eventName === "cancel_turn") {
+                            try {
+                                const payload = JSON.parse(data);
+                                if (payload.sessionId && payload.sessionId !== sessionId) {
+                                    continue;
+                                }
+                            }
+                            catch {
+                                /* ignore malformed payload */
+                            }
+                            handlers.onCancelTurn?.();
+                        }
+                        else if (eventName === "user_file_edit") {
+                            try {
+                                const edit = JSON.parse(data);
+                                if (edit.sessionId && edit.sessionId !== sessionId) {
+                                    continue;
+                                }
+                                const requestId = edit.requestId || edit.request_id;
+                                if (requestId && edit.path) {
+                                    handlers.onUserFileEdit?.({
+                                        requestId,
+                                        path: edit.path,
+                                        content: edit.content ?? "",
+                                    });
+                                }
+                            }
+                            catch {
+                                /* ignore */
+                            }
+                        }
                         else if (eventName === "user_message" || eventName === "message") {
                             try {
                                 const msg = JSON.parse(data);
@@ -1441,6 +1594,15 @@ export async function runChimphands(opts) {
     let sessionActive = true;
     let lastUserActivity = Date.now();
     let exitCode;
+    let cancelTurnRequested = false;
+    let activeOpencodeChild = null;
+    let agentTurnInProgress = false;
+    const turnControl = {
+        getCancelRequested: () => cancelTurnRequested,
+        onActiveChild: (child) => {
+            activeOpencodeChild = child;
+        },
+    };
     const enqueueUserMessage = (msg) => {
         const id = msg.id?.trim();
         if (id) {
@@ -1512,6 +1674,21 @@ export async function runChimphands(opts) {
         onIdle: () => {
             idle = true;
         },
+        onCancelTurn: () => {
+            cancelTurnRequested = true;
+            const ch = activeOpencodeChild;
+            if (ch && !ch.killed) {
+                try {
+                    ch.kill("SIGTERM");
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        },
+        onUserFileEdit: (edit) => {
+            void applyUserFileEdit(backend, apiKey, sessionId, edit, () => agentTurnInProgress);
+        },
         shouldRun: () => sessionActive,
     });
     const shutdownRuntime = async () => {
@@ -1584,6 +1761,8 @@ export async function runChimphands(opts) {
             tick();
         });
         while (prompt) {
+            cancelTurnRequested = false;
+            agentTurnInProgress = true;
             let useOpencodeSessionId = opencodeSessionId;
             let isNewOpencodeSession = !useOpencodeSessionId;
             let effectivePrompt = wrapPromptWithContext(conversationSummary, prompt, isNewOpencodeSession, workingBranch, pullRequestUrl);
@@ -1601,6 +1780,7 @@ export async function runChimphands(opts) {
                 },
                 onWorkingBranch: noteWorkingBranch,
                 postEvent: turnPostEvent,
+                ...turnControl,
             }, attachUrl);
             if (result.code !== 0 &&
                 useOpencodeSessionId &&
@@ -1619,8 +1799,10 @@ export async function runChimphands(opts) {
                     },
                     onWorkingBranch: noteWorkingBranch,
                     postEvent: turnPostEvent,
+                    ...turnControl,
                 }, attachUrl);
             }
+            agentTurnInProgress = false;
             await poster.flush();
             if (result.opencodeSessionId) {
                 opencodeSessionId = result.opencodeSessionId;
@@ -1643,7 +1825,7 @@ export async function runChimphands(opts) {
                     console.error(`ChimpHands turn-end reconcile failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
             }
-            if (result.code !== 0) {
+            if (result.code !== 0 && !result.cancelled) {
                 const errMsg = (result.err || "opencode failed").trim() || "opencode failed";
                 console.error(`ChimpHands OpenCode failed: ${errMsg}`);
                 try {
@@ -1667,7 +1849,12 @@ export async function runChimphands(opts) {
                 exitCode = result.code || 1;
                 break;
             }
-            postEvent(ROLE_STATUS, "Waiting for user input", { status: STATUS_WAITING_USER });
+            if (result.cancelled) {
+                postEvent(ROLE_STATUS, "Turn stopped", { status: STATUS_WAITING_USER });
+            }
+            else {
+                postEvent(ROLE_STATUS, "Waiting for user input", { status: STATUS_WAITING_USER });
+            }
             lastUserActivity = Date.now();
             idle = false;
             prompt = (await waitForNextPrompt()) || "";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@testchimp/cli",
-  "version": "0.1.57",
+  "version": "0.1.59",
   "description": "TestChimp CLI and MCP server — coverage, plans, EaaS, TrueCoverage, API operations (calls /api/mcp/*)",
   "type": "module",
   "main": "dist/bin/testchimp.js",