little-coder 1.9.4 → 1.9.5

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

@@ -8,7 +8,6 @@ import {
   type SubCoderResult,
 } from "./spawn.ts";
 import { SubCoderTracker } from "./tracker.ts";
-import { truncateLineToWidth } from "../_shared/width.ts";
 
 // The `dispatch` tool: the main little-coder spawns isolated child little-coder
 // sessions ("sub-coders") to research a focused question — they read the repo
@@ -191,22 +190,106 @@ export default function (pi: ExtensionAPI) {
   });
 }
 
-/** A minimal pi-tui Component backed by precomputed lines.
+/**
+ * Sanitize and wrap lines for the dispatch tool-result panel.
  *
- * pi paints custom tool-result panels with a 1-char left margin + background-
- * frame fill, so any line we hand back that's wider than `width - 1` overflows
- * the terminal and crashes pi-tui (issue #51 / reopen of #48 — the dispatch
- * renderer fed an unbounded sub-coder report sentence into the panel, and on
- * `--resume` the same renderer paints session history, so the crash recurred
- * even after v1.9.2 capped the *live* tracker). We respect the pi-supplied
- * `width` here and truncate every line to `width - 2`, leaving a 2-char
- * safety margin so wide unicode chars in the report can't sneak past our
- * char-count-based visibleWidth approximation. */
+ * 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[] {
       const cap = Math.max(1, width - 2);
-      return lines.map((l) => truncateLineToWidth(l, cap));
+      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

@@ -8,14 +8,20 @@ import { makeComponent } from "./index.ts";
 // `--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. This test drives makeComponent at the
-// same width with the same shape and asserts no emitted line exceeds.
+// 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("caps a wide sub-coder report line to fit the pi-supplied width", () => {
+  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.
@@ -30,12 +36,23 @@ describe("issue #51 — dispatch renderResult doesn't overflow", () => {
       "(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 truncated wide sentence keeps its prefix verbatim — it's not blanked
-    // out, just clipped with an ellipsis so the user can still read most of it.
-    const truncated = out[3];
-    expect(stripAnsi(truncated).startsWith("There is **no")).toBe(true);
+    // 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", () => {
@@ -51,4 +68,13 @@ describe("issue #51 — dispatch renderResult doesn't overflow", () => {
     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,16 @@
 
 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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "little-coder",
-  "version": "1.9.4",
+  "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": {