little-coder 1.9.3 → 1.9.5

package/.pi/extensions/subagent/index.ts

@@ -190,11 +190,106 @@ export default function (pi: ExtensionAPI) {
   });
 }
 
-/** A minimal pi-tui Component backed by precomputed lines. */
-function makeComponent(lines: string[]) {
+/**
+ * Sanitize and wrap lines for the dispatch tool-result panel.
+ *
+ * Two problems we solve:
+ * 1. Long whitespace-free tokens (URLs, file paths, base64) are broken up
+ *    so word-wrap has somewhere to split — follows openclaw-cn's
+ *    tui-formatters.ts sanitizer (commit 8c822da).
+ * 2. Each line is wrapped to the pi-supplied width so no rendered line
+ *    exceeds the terminal — the failure mode of issues #48 / #51 (a 134-char
+ *    sub-coder report sentence + pi's 1-char panel left margin overflowed
+ *    pi-tui's strict line-width check, including on `--resume` because the
+ *    same renderer paints session history).
+ *
+ * Word-wrap was contributed by @steverhoades in PR #49; v1.9.5 cherry-picked
+ * it onto v1.9.4 because wrapping is a strictly better UX for markdown
+ * report bodies than the truncate-with-ellipsis we shipped in v1.9.4 — the
+ * user sees the whole sentence across multiple lines instead of a cut-off
+ * tail. The 2-char safety margin (`width - 2`) survives wide-unicode chars
+ * our char-count-based stripAnsi/length undercounts, and absorbs pi's panel
+ * frame margin so the rendered output still fits.
+ *
+ * pi-tui's own visibleWidth / truncateToWidth aren't importable here (pi
+ * 0.79 stopped hoisting pi-tui for extensions), so the ANSI-aware helpers
+ * are inlined.
+ */
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const MAX_TOKEN_CHARS = 32;
+const LONG_TOKEN_RE = /\S{33,}/g;
+
+function chunkToken(token: string): string[] {
+  const chunks: string[] = [];
+  for (let i = 0; i < token.length; i += MAX_TOKEN_CHARS) {
+    chunks.push(token.slice(i, i + MAX_TOKEN_CHARS));
+  }
+  return chunks;
+}
+
+function sanitizeLongTokens(text: string): string {
+  return LONG_TOKEN_RE.test(text)
+    ? text.replace(LONG_TOKEN_RE, (token) => chunkToken(token).join(" "))
+    : text;
+}
+
+/** Extract leading ANSI SGR codes so wrapped lines can re-apply them. */
+function extractAnsiPrefix(text: string): { prefix: string; rest: string } {
+  let end = 0;
+  while (end < text.length && text.slice(end, end + 2) === "\x1b[") {
+    const mPos = text.indexOf("m", end + 2);
+    if (mPos === -1) break;
+    end = mPos + 1;
+  }
+  return { prefix: text.slice(0, end), rest: text.slice(end) };
+}
+
+function stripAnsi(text: string): string {
+  return text.replace(ANSI_RE, "");
+}
+
+/** Word-wrap plain text at whitespace; assumes long tokens are pre-chunked. */
+function wrapPlainText(text: string, maxWidth: number): string[] {
+  if (text.length <= maxWidth) return [text];
+  const words = text.split(/\s+/);
+  const result: string[] = [];
+  let current = "";
+  for (const word of words) {
+    if (!word) continue;
+    if (current.length === 0) {
+      current = word;
+    } else if (current.length + 1 + word.length <= maxWidth) {
+      current += " " + word;
+    } else {
+      result.push(current);
+      current = word;
+    }
+  }
+  if (current) result.push(current);
+  return result.length > 0 ? result : [text];
+}
+
+/** Wrap one ANSI-aware line to width, re-applying any leading SGR prefix. */
+function wrapLine(line: string, width: number): string[] {
+  const plain = stripAnsi(line);
+  if (plain.length <= width) return [line];
+  const { prefix } = extractAnsiPrefix(line);
+  const wrappedLines = wrapPlainText(plain, width);
+  return wrappedLines.map((l) => prefix + l);
+}
+
+export function makeComponent(lines: string[]) {
   return {
-    render(_width: number): string[] {
-      return lines;
+    render(width: number): string[] {
+      const cap = Math.max(1, width - 2);
+      const output: string[] = [];
+      for (const line of lines) {
+        const sanitized = sanitizeLongTokens(line);
+        for (const wrapped of wrapLine(sanitized, cap)) {
+          output.push(wrapped);
+        }
+      }
+      return output;
     },
     invalidate() {},
   };

package/.pi/extensions/subagent/issue-51-repro.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect } from "vitest";
+import { makeComponent } from "./index.ts";
+
+// Live regression for issue #51 (and the #48 reopen — same root cause from a
+// different code path). pi paints the dispatch tool-result panel with a 1-char
+// background-color left margin + fill; any line we return wider than
+// `width - 1` overflows pi-tui and crashes the session, including on
+// `--resume` because pi re-renders saved tool results from session history.
+//
+// The user's crash log showed a 134-char sub-coder report sentence rendered
+// at terminal width 133 → 135 > 133.
+//
+// v1.9.4 fixed this by truncating to width-2. v1.9.5 (PR #49 by
+// @steverhoades) replaced the truncation with **word-wrap**: a 134-char
+// sentence becomes two visual lines that together preserve the full
+// sentence, instead of dropping the tail. Both behaviors satisfy the
+// width invariant — this test asserts (a) no emitted line exceeds and (b)
+// the wide content is preserved across the wrapped lines (no data loss).
+
+const stripAnsi = (s: string) => s.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+const visibleWidth = (s: string) => stripAnsi(s).length;
+
+describe("issue #51 — dispatch renderResult doesn't overflow", () => {
+  it("wraps a wide sub-coder report line to fit the pi-supplied width", () => {
+    const wideSentence =
+      "There is **no `rate_limits` table**. The entire file defines a single class, `ConversationStore`, which manages only one SQLite table:";
+    // Sanity: this is the exact 134-char shape from the user's crash log.
+    expect(wideSentence.length).toBeGreaterThan(133);
+    const comp = makeComponent([
+      "✓ Storage schema",
+      "**Report: `bot/storage.py` Schema Analysis**",
+      "",
+      wideSentence,
+      "",
+      "  …",
+      "(Ctrl+O to expand)",
+    ]);
+    const out = comp.render(133);
+    // Width invariant: no emitted line exceeds the pi-supplied width.
+    const max = Math.max(...out.map((l) => visibleWidth(l)));
+    expect(max).toBeLessThanOrEqual(133);
+    // The wide sentence wraps but is preserved: rejoining the wrapped lines
+    // (collapsing whitespace) reproduces the original prose verbatim. That's
+    // the user-visible win over v1.9.4's truncate-with-ellipsis.
+    const wrappedRoundtrip = out
+      .map((l) => stripAnsi(l))
+      .join(" ")
+      .replace(/\s+/g, " ")
+      .trim();
+    expect(wrappedRoundtrip).toContain(
+      "There is **no `rate_limits` table**. The entire file defines a single class, `ConversationStore`, which manages only one SQLite table:",
+    );
+    // And it's wrapped, not truncated — there are more emitted lines than
+    // input lines because the long sentence split.
+    expect(out.length).toBeGreaterThan(7);
+  });
+
+  it("survives a narrow terminal (40 cols) without throwing", () => {
+    const comp = makeComponent([
+      "very long content " + "x".repeat(500),
+      "another long line " + "y".repeat(200),
+    ]);
+    const out = comp.render(40);
+    expect(Math.max(...out.map((l) => visibleWidth(l)))).toBeLessThanOrEqual(40);
+  });
+
+  it("preserves short lines unchanged", () => {
+    const comp = makeComponent(["short", "tiny"]);
+    expect(comp.render(133)).toEqual(["short", "tiny"]);
+  });
+
+  it("chunks long whitespace-free tokens (URLs/paths) so wrapping has room to split", () => {
+    // A 200-char URL-ish token has no spaces; without sanitizeLongTokens it
+    // would defeat word-wrap and overflow at any narrow width.
+    const url = "https://example.com/" + "a".repeat(200);
+    const comp = makeComponent([url]);
+    const out = comp.render(60);
+    expect(Math.max(...out.map((l) => visibleWidth(l)))).toBeLessThanOrEqual(60);
+  });
+});

package/CHANGELOG.md

@@ -2,6 +2,26 @@
 
 All notable changes to little-coder are documented here. The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/), and little-coder's public interface (CLI, providers, tools, skills) follows semver starting at `v0.0.1` post-rename.
 
+## [v1.9.5] — 2026-06-18
+
+### Changed
+- **Dispatch tool-result panel now word-wraps wide report lines instead of truncating them** ([PR #49](https://github.com/itayinbarr/little-coder/pull/49) by [@steverhoades](https://github.com/steverhoades), closes [#48](https://github.com/itayinbarr/little-coder/issues/48) and [#51](https://github.com/itayinbarr/little-coder/issues/51)). v1.9.4 fixed the width-overflow crash by truncating each panel line to `width - 2` with an ellipsis; v1.9.5 replaces the truncation with **word-wrap** so the full sentence survives across multiple visual lines — a strictly better UX for markdown sub-coder reports than dropping the tail at char 131. The cherry-picked commit (steverhoades's authorship preserved) keeps the wrap helpers (ANSI-aware prefix extraction, long-token chunking for whitespace-free URLs/paths/base64 that would otherwise defeat word-wrap, plain-text word-wrap), and the `makeComponent.render(width)` is rebased onto v1.9.4's `width - 2` safety margin so wide-unicode chars our char-count `visibleWidth` undercounts still can't sneak past pi's strict line-width check. Inspiration for the long-token sanitizer credited in-source to [openclaw-cn's tui-formatters.ts](https://github.com/mf-yang/openclaw-cn/commit/8c822da26f0a77396107a31f09df60817bf39c98). `issue-51-repro.test.ts` updated for wrap semantics (4 cases): no emitted line exceeds; the wrapped lines round-trip to the original 134-char sentence verbatim (no data loss); narrow terminal (40 cols) survives; 200-char URL-ish tokens get chunked so wrapping has room to split.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. If you upgraded from v1.9.3 → v1.9.4 → v1.9.5, the user-visible difference between the last two is just wrap-vs-truncate in the dispatch tool's expanded report panel — both eliminate the crash. If you saw an ellipsis at the right edge of a sub-coder report on v1.9.4, you'll now see the full sentence wrapped onto the next line instead.
+
+---
+
+## [v1.9.4] — 2026-06-18
+
+### Fixed
+- **Dispatch tool-result panel overflows the terminal on wide report lines** ([#51](https://github.com/itayinbarr/little-coder/issues/51), reopen of [#48](https://github.com/itayinbarr/little-coder/issues/48)). v1.9.2 capped every line the *live* sub-coder tracker emitted, but the **dispatch tool's result renderer** (`subagent/index.ts`'s `makeComponent`) was still ignoring the `width` arg pi passes to `render(width)` — it returned the precomputed lines verbatim. pi paints the tool-result panel with a 1-char background-color left margin, so any sub-coder report sentence wider than `terminal_width - 1` overflowed pi-tui. Crash log line 453 was a 134-char markdown sentence rendered at terminal width 133 → 135 > 133. The same path runs on **`--resume`** (pi re-paints saved tool results from session history), so v1.9.2 users still hit it after upgrading whenever they resumed a session with a wide dispatch report saved — that's why @steverhoades caught the regression. `makeComponent` now truncates every emitted line to `width - 2` using the existing `_shared/width.ts` utility (2-char safety margin for wide unicode under our char-count-based `visibleWidth` approximation), so the dispatch panel can no longer crash a session — live, on resume, or anywhere else. New `subagent/issue-51-repro.test.ts` drives `makeComponent` with the user's exact 134-char content shape at width 133 and asserts no emitted line exceeds, plus a narrow-terminal (40-col) survival check.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. If you saw `Rendered line N exceeds terminal width` on v1.9.2 / 1.9.3 — especially while *resuming* a session — 1.9.4 fixes it. If you still see it after upgrading, the offending line in `~/.pi/agent/pi-crash.log` should let us spot the source; reopen #51 or #48 with the log attached.
+
+---
+
 ## [v1.9.3] — 2026-06-18
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.9.3",
+  "version": "1.9.5",
   "description": "A pi-based coding agent optimized for small local language models. Reproduces the whitepaper's scaffold-model-fit adaptations as pi extensions.",
   "homepage": "https://github.com/itayinbarr/little-coder",
   "repository": {