little-coder 1.9.4 → 1.9.6

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,29 @@
 
 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.6] — 2026-06-18
+
+### Fixed
+- **Auto-update silently failed on Windows** ([PR #52](https://github.com/itayinbarr/little-coder/pull/52) by [@i-snyder](https://github.com/i-snyder)). On Windows `npm` is `npm.cmd` (a batch-file shim), and `spawnSync("npm", …)` without `shell: true` returns `ENOENT` before npm ever launches — the user saw `✗ Update failed (npm exit null). Continuing with v1.9.x.`, where the `null` exit code was the tell that npm never ran. The launcher now invokes `npm` via `process.env.COMSPEC /c npm` on Windows (`shell: true` would also work but triggers Node 24+'s `DEP0190` deprecation warning; COMSPEC doesn't). Cross-platform behavior unchanged: POSIX still uses plain `spawnSync("npm", …)`. The failure message is also fixed — when the spawn itself fails (`result.error` is set), the launcher now surfaces `result.error.code` (e.g. `ENOENT`) instead of `result.status` (which is `null` and meaningless), so users diagnosing future spawn failures get an actionable code instead of `npm exit null`.
+
+### Added
+- **`little-coder --update` forces a fresh update check** ([PR #52](https://github.com/itayinbarr/little-coder/pull/52) by [@i-snyder](https://github.com/i-snyder)). The launcher caches the registry "latest" lookup for 12 hours; `--update` bypasses that cache and fetches fresh from npm, then either updates or prints `✓ little-coder is already up to date (v<x>)`. The flag is stripped from argv before forwarding to pi, so `little-coder --update` no longer errors with `Unknown option: --update`. Two new `shouldSkip` tests document the interaction (the flag forces a check; the notice-only mode still applies on non-TTY).
+
+### Notes for upgraders
+- No CLI-flag or public-API breakage. Windows users on v1.9.5 or earlier should manually `npm install -g little-coder@1.9.6` this once; future updates will work via the in-app prompt or `little-coder --update`.
+
+---
+
+## [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/bin/little-coder.mjs

@@ -135,7 +135,8 @@ try {
   // ignore — update-check just won't fire if we can't read the version
 }
 if (!isSubagent) {
-  const exitAfterCheck = await checkForUpdate(currentVersion);
+  const forceUpdate = process.argv.includes("--update");
+  const exitAfterCheck = await checkForUpdate(currentVersion, { force: forceUpdate });
   if (exitAfterCheck) {
     // Successful update happened; user needs to re-run the new binary.
     process.exit(0);
@@ -148,7 +149,9 @@ if (!isSubagent) {
 // --system-prompt    : load <pkgRoot>/AGENTS.md regardless of cwd
 //
 // Strip our own flags before forwarding to pi so it doesn't reject them.
-const userArgs = process.argv.slice(2).filter((a) => a !== "--no-update-check");
+const userArgs = process.argv.slice(2).filter(
+  (a) => a !== "--no-update-check" && a !== "--update",
+);
 const agentsMd = join(pkgRoot, "AGENTS.md");
 
 // Default the thinking level to "medium" for interactive sessions (pi's own

package/bin/update-check.mjs

@@ -123,17 +123,28 @@ function promptYesNo(question) {
 // Returns `true` if the launcher should NOT proceed to spawn pi (because we
 // updated and exited / the user opted out and we should re-run).  Returns
 // `false` to let the launcher continue.
+//
+// opts.force — bypass the 12h cache and always fetch the latest version from
+//   the registry. Used when the user explicitly passes `--update`. If already
+//   at the latest version, prints a short "up to date" notice instead of
+//   silently returning.
 export async function checkForUpdate(currentVersion, opts = {}) {
   const skip = opts.skip ?? shouldSkip();
   if (skip === true) return false;
 
-  let latest = readCache()?.latest;
+  const force = opts.force ?? false;
+  let latest = (!force && readCache()?.latest) || null;
   if (!latest) {
     latest = await fetchLatest();
     if (latest) writeCache(latest);
   }
   if (!latest) return false;
-  if (compareSemver(latest, currentVersion) <= 0) return false;
+  if (compareSemver(latest, currentVersion) <= 0) {
+    if (force) {
+      process.stderr.write(`\n   ✓ little-coder is already up to date (v${currentVersion}).\n\n`);
+    }
+    return false;
+  }
 
   const headline =
     `\n📦 little-coder v${latest} is available (you have v${currentVersion}).`;
@@ -151,17 +162,25 @@ export async function checkForUpdate(currentVersion, opts = {}) {
   }
 
   process.stderr.write(`\n   Running: npm install -g little-coder@${latest}\n\n`);
-  const result = spawnSync("npm", ["install", "-g", `little-coder@${latest}`], {
-    stdio: "inherit",
-  });
+  // On Windows `npm` resolves to `npm.cmd`, a batch-file shim that Node's
+  // spawnSync cannot execute without shell:true. However, shell:true with
+  // array args triggers DEP0190 on Node 24+. Instead, invoke cmd.exe directly
+  // via COMSPEC — it resolves `npm` to `npm.cmd` itself, no shell:true needed.
+  const npmArgs = ["install", "-g", `little-coder@${latest}`];
+  const result = process.platform === "win32"
+    ? spawnSync(process.env.COMSPEC || "cmd.exe", ["/c", "npm", ...npmArgs], { stdio: "inherit" })
+    : spawnSync("npm", npmArgs, { stdio: "inherit" });
   if (result.status === 0) {
     process.stderr.write(
       `\n   ✓ Updated to v${latest}. Re-run \`little-coder\` to use the new version.\n\n`,
     );
     return true;
   }
+  const exitDesc = result.error
+    ? `could not launch npm (${result.error.code ?? result.error.message})`
+    : `npm exit ${result.status}`;
   process.stderr.write(
-    `\n   ✗ Update failed (npm exit ${result.status}). Continuing with v${currentVersion}.\n\n`,
+    `\n   ✗ Update failed (${exitDesc}). Continuing with v${currentVersion}.\n\n`,
   );
   return false;
 }

package/bin/update-check.test.mjs

@@ -161,4 +161,12 @@ describe("shouldSkip", () => {
   it("returns notice-only on non-TTY pipelines", () => {
     expect(shouldSkip([], noEnv, pipeStdout())).toBe("notice-only");
   });
+
+  it("does not skip for --update (it forces the check, not skips it)", () => {
+    expect(shouldSkip(["--update"], noEnv, ttyStdout())).toBe(false);
+  });
+
+  it("notice-only still applies with --update on non-TTY", () => {
+    expect(shouldSkip(["--update"], noEnv, pipeStdout())).toBe("notice-only");
+  });
 });

package/package.json

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