@cspeach/cli 0.7.1 → 0.8.0

package/dist/renderer/question-normalizer.js

@@ -74,26 +74,36 @@ function findBalancedJson(text, from) {
  * Returns the offset where the block begins in `text`.
  */
 function findBlockStart(text, jsonStart) {
-    let pos = jsonStart;
     // Walk backward over preceding lines that are empty, the sentinel, or
     // a fence-open marker. Stop on any line that has other content.
-    while (pos > 0) {
-        const prevNewline = text.lastIndexOf('\n', pos - 1);
+    //
+    // 2026-06-06 — rewritten to guarantee forward progress. The previous
+    // version set `pos = lineStart` and looped; when the `{` sat at the
+    // start of a line (lineStart === pos — the CANONICAL widget shape),
+    // pos never moved and the loop spun forever, pegging a core. The scan
+    // position now steps over the preceding newline each iteration
+    // (strictly decreasing), and the accepted block start is tracked
+    // separately so the return value is still a line-start offset.
+    let blockStart = jsonStart;
+    let scanEnd = jsonStart; // exclusive end of the line-chunk under examination
+    while (scanEnd > 0) {
+        const prevNewline = text.lastIndexOf('\n', scanEnd - 1);
         const lineStart = prevNewline === -1 ? 0 : prevNewline + 1;
-        const line = text.slice(lineStart, pos).trim();
+        const line = text.slice(lineStart, scanEnd).trim();
         if (line === '' ||
             line === SENTINEL ||
             /^```(?:cspeach-widget:\S+)?$/.test(line) ||
             /^````(?:cspeach-widget:\S+)?$/.test(line)) {
-            pos = lineStart;
+            blockStart = lineStart;
             if (prevNewline === -1)
                 break;
+            scanEnd = prevNewline; // step over the newline — strictly decreasing
         }
         else {
             break;
         }
     }
-    return pos;
+    return blockStart;
 }
 /**
  * Walk forward from `jsonEnd` (one past the closing `}`) to include a

package/dist/repl.js

@@ -715,6 +715,12 @@ export async function runRepl(opts) {
                             last_skill: session.last_skill ?? null,
                             last_object: extractedObject ?? session.last_object ?? null,
                         });
+                        if (c.offline) {
+                            // Remote classify failed twice — local-rules fallback fired.
+                            // Tell the user so they know the picker preselection came
+                            // from regex, not the LLM, and surface the real cause.
+                            chunkEmitter.emit('chunk', chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]\n`));
+                        }
                         const decision = decideRouting(c);
                         // 2026-05-17 — pass the just-used skill so the picker can
                         // default cursor to it (one-Enter "continue" UX for follow-up
@@ -868,11 +874,19 @@ export async function runRepl(opts) {
             writeMode: cfg.write_mode,
             onInterrupt,
         }), {
-            // Critical: without this Ink calls process.exit() on Ctrl+C and
-            // kills the CLI before our onInterrupt handler can decide what
-            // to do. We want to make that decision ourselves (abort turn
-            // vs exit at idle).
+            // exitOnCtrlC: false — Ink would otherwise call process.exit()
+            // on Ctrl+C before onInterrupt can decide whether to abort the
+            // in-flight turn or exit cleanly.
             exitOnCtrlC: false,
+            // W2.1 (2026-05-18) — patchConsole intercepts console.log /
+            // console.error / console.warn from inside ANY code that runs
+            // while Ink owns the frame, routes them above the Ink render
+            // region as Static-committed scrollback rather than corrupting
+            // the live frame. CC uses this (12 hits in v0.2.9 source).
+            // Removes a whole class of "console.log ate my frame" bugs and
+            // lets us delete the 6 manual chunkEmitter routings we added
+            // in commit 349ff75.
+            patchConsole: true,
         });
         await donePromise;
         unmount();
@@ -1536,6 +1550,9 @@ export async function runRepl(opts) {
                         last_skill: session.last_skill ?? null,
                         last_object: extractedObject ?? session.last_object ?? null,
                     });
+                    if (c.offline) {
+                        console.log(chalk.dim(`↪ [offline classifier — proxy unreachable: ${c.transport_error ?? 'unknown'}]`));
+                    }
                     const decision = decideRouting(c);
                     // 2026-05-17 — pass the just-used skill so the picker can
                     // default cursor to it. session.skill = immediately-previous

package/dist/router/classifier.js

@@ -1,19 +1,85 @@
 import { loadConfig } from '../config/loader.js';
 import { getStore } from '../auth/api-key.js';
+import { classify as classifyLocal } from '../classifier/client.js';
+// 8s — sized to cover the observed Fly cold-start (~3.2s on the 2026-05-20
+// probe) plus headroom for a slow network. Tighter values risk timing out
+// legitimate cold-start hits and burning the retry budget on the same.
+const FETCH_TIMEOUT_MS = 8000;
+// 250ms — long enough for a half-open TCP/keep-alive socket to be fully
+// torn down before we try again, short enough that the user doesn't feel
+// the retry as a hang.
+const RETRY_DELAY_MS = 250;
+/**
+ * Extract the real failure cause from a Node fetch / undici error. Node's
+ * native fetch surfaces `TypeError: fetch failed` and hides the actual
+ * layer on `err.cause` (UND_ERR_*, ENOTFOUND, ECONNRESET, ETIMEDOUT, TLS
+ * handshake aborts, etc.). This lets future failure messages name the
+ * actual layer so we can tell DNS vs TLS vs socket-reset vs Fly cold start.
+ */
+function extractCause(err) {
+    const e = err;
+    if (e.cause) {
+        return `${e.cause.code ?? e.cause.errno ?? 'unknown'}${e.cause.message ? `: ${e.cause.message}` : ''}`;
+    }
+    return e.message;
+}
+async function tryFetchOnce(proxyUrl, key, prompt, context) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), FETCH_TIMEOUT_MS);
+    try {
+        return await fetch(`${proxyUrl}/v1/classify`, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${key}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ prompt, context }),
+            signal: ctrl.signal,
+        });
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
 export async function classifyPrompt(prompt, context) {
     const cfg = await loadConfig();
     const store = await getStore();
     const key = await store.get();
     if (!key)
         throw new Error('no_api_key');
-    const r = await fetch(`${cfg.proxy_url}/v1/classify`, {
-        method: 'POST',
-        headers: {
-            'Authorization': `Bearer ${key}`,
-            'Content-Type': 'application/json',
-        },
-        body: JSON.stringify({ prompt, context }),
-    });
+    let r;
+    let lastErr;
+    // Two attempts total: the second masks the common case of a stale
+    // keep-alive socket reused against a just-cold-suspended Fly machine
+    // (2026-05-20 probe showed first-hit cold = 3.2s, warm = 460ms — the
+    // half-open socket fails fast at the transport layer, then a fresh
+    // connection succeeds). HTTP-level failures (non-2xx) do NOT retry —
+    // they bubble through as before.
+    for (let attempt = 0; attempt < 2; attempt++) {
+        try {
+            r = await tryFetchOnce(cfg.proxy_url, key, prompt, context);
+            break;
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt === 0)
+                await new Promise((res) => setTimeout(res, RETRY_DELAY_MS));
+        }
+    }
+    if (!r) {
+        // Both attempts failed at the transport layer. Degrade to the bundled
+        // local rules so the user's turn is NOT dropped — they still get a
+        // coaching picker (confidence 0.3 < 0.60 = picker decision), and the
+        // REPL surfaces an offline hint with the real cause.
+        const skill = classifyLocal(prompt) ?? 'abap-radar';
+        return {
+            skill,
+            confidence: 0.3,
+            alternates: [],
+            offline: true,
+            transport_error: lastErr ? extractCause(lastErr) : 'unknown',
+        };
+    }
     if (!r.ok)
         throw new Error(`classifier HTTP ${r.status}`);
     return (await r.json());

package/dist/tools/subagent/agent_run.js

@@ -124,6 +124,13 @@ export async function agentRunHandler(args, ctx) {
     // Increment depth env var BEFORE the child runs; restore after.
     const priorDepth = process.env.CSPEACH_AGENT_DEPTH;
     process.env.CSPEACH_AGENT_DEPTH = String(depth + 1);
+    // W2.5 — when read_only is set, build a tool filter that drops every
+    // mutating tool from the subagent's tool list. Saves tokens on the
+    // sub-agent invocation (smaller tools array = less input cost) AND
+    // hard-prevents accidental writes from the subagent.
+    const toolFilter = args.read_only
+        ? (t) => !t.isMutating
+        : undefined;
     try {
         await runTurn({
             provider: ctx.provider,
@@ -132,6 +139,7 @@ export async function agentRunHandler(args, ctx) {
             ctx: childCtx,
             chunkEmitter: nullSinkEmitter,
             maxTokensOverride,
+            toolFilter,
         });
     }
     catch (err) {
@@ -179,6 +187,10 @@ registerTool({
                 type: 'number',
                 description: 'Optional per-call cap. Default 100000, hard cap 200000.',
             },
+            read_only: {
+                type: 'boolean',
+                description: 'When true, the subagent only sees read-only tools (no sap_set_source, no file-write, no shell_exec, etc.). Use this for research / analysis subagents that should not make changes — e.g. spawning a subagent to read code, run greps, or summarise findings. Smaller tools array = lower per-call cost; also a hard guard against accidental writes.',
+            },
         },
         required: ['skill', 'task'],
     },

package/dist/ui/body.js

@@ -3,6 +3,56 @@ import React, { useReducer, useEffect } from 'react';
 import { Text, Static } from 'ink';
 import { WIDGET_COMPONENTS } from './widgets/component-registry.js';
 import { WIDGET_CONTROL } from './widget-control.js';
+/**
+ * Frame interval for batching streaming chunks before dispatching to the
+ * reducer (W2.2 — 2026-05-18). Ink already throttles its stdout writes to
+ * 32 ms via `es-toolkit/compat throttle` at the renderer level — but the
+ * React **reducer** still runs once per chunk in our useReducer setup.
+ * For a long code-gen turn (5000+ chunks of 1-3 bytes each), the cumulative
+ * regex-split + string-concat cost in `bodyReducer` becomes the hotspot.
+ *
+ * Batching here gives one reducer call per ~16 ms regardless of chunk rate,
+ * preserving the perceived "real-time stream" feel (still 60Hz) while
+ * collapsing reducer work by 1-2 orders of magnitude on dense streams.
+ *
+ * `requestAnimationFrame` is unavailable in Node, so we use `setTimeout(16)` —
+ * same effective cadence, cross-platform safe. We re-arm the timer only when
+ * a chunk arrives and no flush is pending, so an idle stream pays nothing.
+ */
+export const RENDER_BATCH_MS = 16;
+export function createChunkBatcher(onFlush, intervalMs = RENDER_BATCH_MS) {
+    let buffered = '';
+    let timer = null;
+    const fire = () => {
+        timer = null;
+        if (buffered.length === 0)
+            return;
+        const out = buffered;
+        buffered = '';
+        onFlush(out);
+    };
+    return {
+        push(chunk) {
+            if (chunk.length === 0)
+                return;
+            buffered += chunk;
+            if (timer === null) {
+                timer = setTimeout(fire, intervalMs);
+            }
+        },
+        dispose() {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            if (buffered.length > 0) {
+                const out = buffered;
+                buffered = '';
+                onFlush(out);
+            }
+        },
+    };
+}
 // WIDGET_CONTROL is the longer sentinel (`\x00CSPEACH-WIDGET-V3\x00`).
 // RegExp escaping: `\x00` works in JS regex source directly.
 const WIDGET_RE = new RegExp(WIDGET_CONTROL.replace(/[.*+?^${}()|[\]\\]/g, '\\$&') +
@@ -105,9 +155,18 @@ function renderNode(n) {
 export const Body = React.memo(function Body({ chunkEmitter }) {
     const [state, dispatch] = useReducer(bodyReducer, INITIAL_BODY_STATE);
     useEffect(() => {
-        const handler = (chunk) => dispatch({ chunk });
+        // W2.2 — chunk batching. createChunkBatcher buffers incoming chunks
+        // and dispatches at most once per RENDER_BATCH_MS window. Idle stream
+        // pays nothing; dense stream (e.g. 5000 chunks during code-gen) sees
+        // ~60 reducer calls instead of 5000. dispose() flushes pending text
+        // synchronously on unmount so end-of-stream output isn't dropped.
+        const batcher = createChunkBatcher((buffered) => dispatch({ chunk: buffered }));
+        const handler = (chunk) => batcher.push(chunk);
         chunkEmitter.on('chunk', handler);
-        return () => { chunkEmitter.off('chunk', handler); };
+        return () => {
+            chunkEmitter.off('chunk', handler);
+            batcher.dispose();
+        };
     }, [chunkEmitter]);
     // <Static> takes the nodes array; on each render it appends ONLY new
     // items since the last render. Already-rendered items are not

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cspeach/cli",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "CSPeach — AI-assisted ABAP development CLI. Direct SAP access, 34 skills, safety gates.",
   "keywords": [
     "abap",
@@ -40,6 +40,7 @@
     "adt:smoke": "tsx scripts/adt-smoke.ts",
     "smoke:all": "pnpm zcspeach:smoke && pnpm adt:smoke",
     "zcspeach:smoke": "tsx scripts/zcspeach-smoke.ts",
+    "bench:models": "tsx scripts/bench-models.ts",
     "prepare": "husky"
   },
   "engines": {