little-coder 1.9.2 → 1.9.4

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

@@ -8,6 +8,7 @@ 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
@@ -190,11 +191,22 @@ export default function (pi: ExtensionAPI) {
   });
 }
 
-/** A minimal pi-tui Component backed by precomputed lines. */
-function makeComponent(lines: string[]) {
+/** A minimal pi-tui Component backed by precomputed lines.
+ *
+ * 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. */
+export function makeComponent(lines: string[]) {
   return {
-    render(_width: number): string[] {
-      return lines;
+    render(width: number): string[] {
+      const cap = Math.max(1, width - 2);
+      return lines.map((l) => truncateLineToWidth(l, cap));
     },
     invalidate() {},
   };

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

@@ -0,0 +1,54 @@
+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. This test drives makeComponent at the
+// same width with the same shape and asserts no emitted line exceeds.
+
+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", () => {
+    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);
+    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);
+  });
+
+  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"]);
+  });
+});

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.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
+- **`LITTLE_CODER_EXTRA_EXTENSIONS` env var: layer third-party pi extensions onto the bundled set without forking the installed package** ([#46](https://github.com/itayinbarr/little-coder/issues/46)). Path-delimited list (`:` on POSIX, `;` on Windows — `node:path.delimiter`) of extension paths. Each entry can be a direct file (e.g. a `pi-ponytail`-style `extensions/ponytail.js`) or a directory containing `index.ts` / `index.js` (the launcher prefers `.ts`). A leading `~/` is expanded; missing paths log a one-line warning to stderr and are skipped (a typo in the env var doesn't kill the session). Survives upgrades — drop the env var into your shell rc once and every `little-coder` run picks up the extras. Example: `LITTLE_CODER_EXTRA_EXTENSIONS=~/.local/lib/node_modules/pi-ponytail/extensions/ponytail.js little-coder`. Parsing rules live in `bin/extras.mjs` so they're unit-testable in isolation (9 cases covering direct-file / dir-index-resolution / `index.ts`-preference / missing-path warning / `~/` expansion / multiple entries / whitespace trimming). The launcher-level integration is exercised end-to-end (warning prints for a bad path; valid paths pass through silently to pi as `--extension <entry>` flags). Closest siblings — third-party skill bundles — are not yet covered; `skill-inject` still discovers only `<pkgRoot>/skills/tools/*.md`, and a follow-up will add the same kind of override.
+
+### Notes for upgraders
+- No CLI-flag or public-API changes. The new env var is opt-in: unset = identical behavior to v1.9.2. If you were carrying a custom wrapper extension inside the installed npm package (which gets wiped on upgrade), you can drop it and use the env var instead.
+
+---
+
 ## [v1.9.2] — 2026-06-18
 
 ### Fixed

package/README.md

@@ -67,6 +67,7 @@ The agent uses the directory you launched it from as its working directory — `
 - **Sub-coders (`dispatch`)** — little-coder can spawn isolated child sessions to research a question (read the repo + browse online, read-only) and report back concisely, without cluttering the main conversation. A live panel above the input tracks them. Tune parallelism with `LITTLE_CODER_SUBCODER_CONCURRENCY` (default 2).
 - **Sessions** — each session is auto-named from your first prompt (rename with `/name`) and shown in the terminal tab title. Use `/resume` to list and reopen past sessions for the current directory.
 - **Read-before-edit** — editing a file requires reading it first, so edits match the file's exact current text.
+- **Third-party extensions (`LITTLE_CODER_EXTRA_EXTENSIONS`)** — path-delimited list (`:` on POSIX, `;` on Windows) of extension paths to layer on top of the bundled set. Each entry can be a direct file (e.g. a `pi-ponytail`-style `extensions/ponytail.js`) or a directory containing `index.ts` / `index.js`. `~/` is expanded; missing paths log a warning and are skipped. Survives upgrades, no patching the installed package. Example: `LITTLE_CODER_EXTRA_EXTENSIONS=~/.local/lib/node_modules/pi-ponytail/extensions/ponytail.js little-coder`. (Single-file extensions can still use `little-coder -e <path>` for one-off loads.)
 
 For local providers (llama.cpp, Ollama, LM Studio) pi expects *some* value in the API-key env even though local servers ignore it:
 

package/bin/extras.mjs

@@ -0,0 +1,56 @@
+// Helpers for layering third-party pi extensions onto little-coder's bundled
+// set. Extracted from the launcher so the parsing rules — path-delimited list,
+// `~/` expansion, directory-with-index resolution, missing-path warning — are
+// directly unit-testable without spawning the whole CLI.
+
+import { existsSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { delimiter, join } from "node:path";
+
+// Given the value of LITTLE_CODER_EXTRA_EXTENSIONS (path-delimited list of
+// extension paths), return the resolved entry files that should be passed to pi
+// as `--extension <entry>` flags. Skips empty segments, expands a leading `~/`,
+// resolves a directory entry to its `index.ts` (preferred) or `index.js`, and
+// records a one-line warning for each missing/unusable path so a typo in the
+// env var doesn't kill the session — it just doesn't load that extension.
+export function parseExtraExtensions(
+  envValue,
+  { home = homedir(), exists = existsSync, stat = statSync } = {},
+) {
+  const entries = [];
+  const warnings = [];
+  for (const raw of String(envValue ?? "").split(delimiter)) {
+    const trimmed = raw.trim();
+    if (!trimmed) continue;
+    const expanded = trimmed === "~"
+      ? home
+      : trimmed.startsWith("~/")
+        ? home + trimmed.slice(1)
+        : trimmed;
+    if (!exists(expanded)) {
+      warnings.push(
+        `little-coder: LITTLE_CODER_EXTRA_EXTENSIONS path not found, skipping: ${expanded}`,
+      );
+      continue;
+    }
+    let entry = expanded;
+    try {
+      if (stat(expanded).isDirectory()) {
+        const candidates = [join(expanded, "index.ts"), join(expanded, "index.js")];
+        const found = candidates.find((p) => exists(p));
+        if (!found) {
+          warnings.push(
+            `little-coder: LITTLE_CODER_EXTRA_EXTENSIONS dir has no index.ts/index.js, skipping: ${expanded}`,
+          );
+          continue;
+        }
+        entry = found;
+      }
+    } catch {
+      // unreadable / racing stat — skip silently
+      continue;
+    }
+    entries.push(entry);
+  }
+  return { entries, warnings };
+}

package/bin/extras.test.mjs

@@ -0,0 +1,119 @@
+import { describe, it, expect } from "vitest";
+import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { delimiter, join } from "node:path";
+import { parseExtraExtensions } from "./extras.mjs";
+
+function setupTmp() {
+  return mkdtempSync(join(tmpdir(), "lc-extras-"));
+}
+
+describe("parseExtraExtensions", () => {
+  it("returns no entries when env is unset / empty", () => {
+    expect(parseExtraExtensions(undefined).entries).toEqual([]);
+    expect(parseExtraExtensions("").entries).toEqual([]);
+    expect(parseExtraExtensions(delimiter + delimiter).entries).toEqual([]);
+  });
+
+  it("forwards a direct file path verbatim", () => {
+    const dir = setupTmp();
+    try {
+      const file = join(dir, "ponytail.js");
+      writeFileSync(file, "export default function(){}");
+      const { entries, warnings } = parseExtraExtensions(file);
+      expect(entries).toEqual([file]);
+      expect(warnings).toEqual([]);
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it("resolves a directory entry to its index.ts (preferred)", () => {
+    const dir = setupTmp();
+    try {
+      const extDir = join(dir, "ponytail");
+      mkdirSync(extDir);
+      writeFileSync(join(extDir, "index.ts"), "");
+      writeFileSync(join(extDir, "index.js"), "");
+      const { entries } = parseExtraExtensions(extDir);
+      expect(entries).toEqual([join(extDir, "index.ts")]);
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it("falls back to index.js when index.ts is absent", () => {
+    const dir = setupTmp();
+    try {
+      const extDir = join(dir, "ponytail");
+      mkdirSync(extDir);
+      writeFileSync(join(extDir, "index.js"), "");
+      const { entries } = parseExtraExtensions(extDir);
+      expect(entries).toEqual([join(extDir, "index.js")]);
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it("warns and skips a directory without index.ts/index.js", () => {
+    const dir = setupTmp();
+    try {
+      const extDir = join(dir, "empty");
+      mkdirSync(extDir);
+      const { entries, warnings } = parseExtraExtensions(extDir);
+      expect(entries).toEqual([]);
+      expect(warnings).toHaveLength(1);
+      expect(warnings[0]).toContain("no index.ts/index.js");
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it("warns and skips a missing path (typo doesn't kill the session)", () => {
+    const { entries, warnings } = parseExtraExtensions("/tmp/does-not-exist-zzz-xyz-123");
+    expect(entries).toEqual([]);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain("path not found");
+  });
+
+  it("expands a leading ~/ using the supplied home", () => {
+    const dir = setupTmp();
+    try {
+      const extDir = join(dir, "fake-home", "ext");
+      mkdirSync(extDir, { recursive: true });
+      writeFileSync(join(extDir, "index.js"), "");
+      const { entries } = parseExtraExtensions("~/ext", {
+        home: join(dir, "fake-home"),
+      });
+      expect(entries).toEqual([join(extDir, "index.js")]);
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it("layers multiple extensions from one path-delimited list", () => {
+    const dir = setupTmp();
+    try {
+      const a = join(dir, "a.js");
+      writeFileSync(a, "");
+      const b = join(dir, "b.js");
+      writeFileSync(b, "");
+      const { entries } = parseExtraExtensions([a, b].join(delimiter));
+      expect(entries).toEqual([a, b]);
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+
+  it("trims whitespace around list entries", () => {
+    const dir = setupTmp();
+    try {
+      const a = join(dir, "a.js");
+      writeFileSync(a, "");
+      const { entries } = parseExtraExtensions(`  ${a}  `);
+      expect(entries).toEqual([a]);
+    } finally {
+      rmSync(dir, { recursive: true });
+    }
+  });
+});

package/bin/little-coder.mjs

@@ -17,6 +17,7 @@ import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { checkForUpdate } from "./update-check.mjs";
+import { parseExtraExtensions } from "./extras.mjs";
 
 // ---- 1. Node version preflight (>= 22.19.0, matching pi.dev) ----
 const MIN_NODE = [22, 19, 0];
@@ -110,6 +111,21 @@ if (existsSync(extDir)) {
   }
 }
 
+// ---- 4b. Third-party extensions via LITTLE_CODER_EXTRA_EXTENSIONS ----
+// Path-delimited list (`:` on POSIX, `;` on Windows — node:path.delimiter)
+// of extra extension paths to load alongside the bundled ones. Each entry can
+// be either a direct file path (e.g. a pi-ponytail-style `extensions/ponytail.js`)
+// or a directory containing `index.ts` / `index.js`. Survives upgrades and
+// avoids the "fork the installed npm package" workaround that issue #46 hit.
+// Parsing rules — ~/ expansion, directory-with-index resolution, one-line
+// warning for missing/unusable entries — live in ./extras.mjs so they're
+// unit-testable in isolation.
+{
+  const { entries, warnings } = parseExtraExtensions(process.env.LITTLE_CODER_EXTRA_EXTENSIONS);
+  for (const w of warnings) console.error(w);
+  for (const entry of entries) extArgs.push("--extension", entry);
+}
+
 // ---- 5. Update check (best-effort, blocks on TTY prompt only) ----
 let currentVersion = "0.0.0";
 try {

package/package.json

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