little-coder 1.3.0 → 1.4.1

package/.pi/extensions/branding/index.ts

@@ -0,0 +1,93 @@
+import type { ExtensionAPI, Theme } from "@mariozechner/pi-coding-agent";
+import { readFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// Replace pi's built-in startup header + terminal title with little-coder
+// branding. The interactive TUI's "pi vX.Y.Z" logo, the "Pi can explain its
+// own features..." onboarding line, and the "π - <cwd>" terminal title all
+// come from pi's APP_NAME / built-in header; this extension swaps them for
+// little-coder's own identity using the public ExtensionUIContext hooks.
+//
+// Pairs with `.pi/settings.json` setting `"quietStartup": true`, which
+// suppresses pi's built-in header AND the loaded-resources dump (the long
+// list of extension paths, skills, prompts, themes that used to flood the
+// screen on launch). Power users can still run `little-coder --verbose` to
+// override quietStartup and see the resource list.
+//
+// Implementation pattern follows the bundled pi example at
+// `node_modules/@mariozechner/pi-coding-agent/examples/extensions/custom-header.ts` —
+// the factory returns a duck-typed Component (`render(width): string[]` +
+// `invalidate()`), so no deep imports from pi-tui are needed.
+
+const TAGLINE = "A coding agent tuned for small local models";
+
+function readVersion(): string {
+  // .pi/extensions/branding/index.ts → up 3 → package root (where package.json lives).
+  // The same path math works in the local checkout (loaded via tsx) and in the
+  // installed npm package layout (node_modules/little-coder/.pi/extensions/branding/).
+  try {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const pkgPath = join(here, "..", "..", "..", "package.json");
+    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+    if (typeof pkg?.version === "string" && pkg.version.length > 0) return pkg.version;
+  } catch {
+    // best-effort; fall through
+  }
+  return "0.0.0";
+}
+
+const VERSION = readVersion();
+
+function buildHeader(theme: Theme): string[] {
+  const logo =
+    theme.bold(theme.fg("accent", "little-coder")) +
+    theme.fg("dim", ` v${VERSION}`);
+  const tagline = theme.fg("muted", TAGLINE);
+  const dim = (s: string) => theme.fg("dim", s);
+  const sep = theme.fg("muted", " · ");
+  const hints = [
+    `${dim("esc")} interrupt`,
+    `${dim("ctrl-l/ctrl-c")} clear/exit`,
+    `${dim("/")} commands`,
+    `${dim("!")} bash`,
+    `${dim("ctrl-r")} more`,
+  ].join(sep);
+  return ["", logo, tagline, "", hints, ""];
+}
+
+function setTitleForCwd(setTitle: (t: string) => void, cwd: string): void {
+  setTitle(`little-coder - ${basename(cwd)}`);
+}
+
+export default function (pi: ExtensionAPI) {
+  // session_start fires on initial load AND on every session switch.
+  // Pi's updateTerminalTitle() runs in init() *after* session_start, so our
+  // setTitle here gets clobbered back to "π - <cwd>". We reassert the title
+  // on turn_start and turn_end too — pi calls updateTerminalTitle at the same
+  // points (interactive-mode.js:1179, 1346, 3971), so re-setting on every
+  // turn keeps our "little-coder - <cwd>" winning for the duration of a
+  // session.
+  pi.on("session_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+
+    ctx.ui.setHeader((_tui, theme) => ({
+      render(_width: number): string[] {
+        return buildHeader(theme);
+      },
+      invalidate() {},
+    }));
+
+    setTitleForCwd(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd);
+  });
+
+  pi.on("turn_start", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    setTitleForCwd(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd);
+  });
+
+  pi.on("turn_end", async (_event, ctx) => {
+    if (!ctx.hasUI) return;
+    setTitleForCwd(ctx.ui.setTitle.bind(ctx.ui), ctx.cwd);
+  });
+}

package/.pi/settings.json

@@ -1,4 +1,5 @@
 {
+  "quietStartup": true,
   "compaction": { "enabled": true },
   "retry": { "enabled": true, "maxRetries": 2 },
   "little_coder": {

package/CHANGELOG.md

@@ -2,6 +2,39 @@
 
 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.4.1] — 2026-05-16
+
+Wire fix for the v1.4.0 startup rebrand. The `[Extensions]` block was still showing for users running from outside the repo root.
+
+### Fixed
+- **`quietStartup` is now actually applied for end users.** v1.4.0 set `"quietStartup": true` in our shipped `.pi/settings.json`, but pi reads global settings from `~/.pi/agent/settings.json` (or the dir pointed to by `PI_CODING_AGENT_DIR`) — not from the npm package's internal `.pi/`. So users running little-coder from anywhere outside the repo root still saw pi's full extension/skill/prompt inventory on startup. The launcher (`bin/little-coder.mjs`) now non-destructively merges `quietStartup: true` into the user's actual global pi settings on every launch, preserving any other keys. To see the inventory anyway: `little-coder --verbose`.
+- **Terminal title now reasserts on `turn_start` / `turn_end`.** Pi's `updateTerminalTitle()` fires multiple times during a session (init, provider count update, session-name change) and was clobbering our `setTitle("little-coder - <cwd>")` back to `π - <cwd>`. The branding extension now re-applies the title on every turn boundary, so after the first prompt the title stays correct.
+
+### Notes for upgraders
+- Existing keys in your `~/.pi/agent/settings.json` are preserved. The launcher only writes `quietStartup` if it isn't already `true`. If you'd previously set `"quietStartup": false` deliberately, you'll see the launcher overwrite it back to `true` — set `--verbose` per-invocation to see the inventory without disabling the global default.
+- No CLI flag, skill-pack, or API changes.
+
+---
+
+## [v1.4.0] — 2026-05-16
+
+Startup UI rebrand. The TUI's opening frame now reads as **little-coder**, not as pi. Pi remains the substrate; the chrome above it just stops pretending it's the product.
+
+### Added
+- **New `.pi/extensions/branding/` extension.** Calls `pi.ui.setHeader()` and `pi.ui.setTitle()` on every `session_start` event to install a little-coder banner: `little-coder vX.Y.Z` (logo) + `A coding agent tuned for small local models` (tagline, verbatim from the README opening line) + a compact keybinding-hint row. The terminal title goes from `π - <cwd>` to `little-coder - <cwd>`. Implementation pattern follows pi's bundled `examples/extensions/custom-header.ts` — the factory returns a duck-typed Component (`render(width): string[]`), so no deep imports of pi-tui internals are required.
+- **Startup screenshot in README.** A real `docs/assets/startup.svg` captured from a live `little-coder` startup, rendered via [charm.sh `freeze`](https://github.com/charmbracelet/freeze). Embedded near the top of the README so the first thing a visitor sees is the actual product, not a description of it.
+
+### Changed
+- **`.pi/settings.json` now ships `"quietStartup": true`.** This is what suppresses pi's built-in loaded-resources block — the long list of extension paths, skills, prompts, themes that previously flooded the screen on every launch. Power users who want the inventory back can pass `little-coder --verbose`, which sets pi's `verbose: true` and overrides `quietStartup`.
+- **Pi's "Pi can explain its own features..." onboarding string is gone.** The branding extension's `setHeader` replaces pi's built-in header entirely, so the line never renders.
+
+### Notes for upgraders
+- No API, settings, or skill-pack breaks. CLI flags unchanged.
+- If you'd customized pi's startup output via your own `models.json` / `.pi/settings.json` override, your changes still apply — the only new top-level key in shipped `.pi/settings.json` is `quietStartup`, and pi's override semantics preserve per-key user values.
+- To restore the original pi-style startup (the `pi vX.Y.Z` logo and the loaded-resources list), run `little-coder --verbose`. There's no way to disable the branding extension from the user side short of editing the installed package, but the rebrand is purely the startup frame — no functional difference.
+
+---
+
 ## [v1.3.0] — 2026-05-16
 
 First functional release of Phase 2 (iterative improvement on real-world coding tasks). Three concrete sharp edges that surfaced while actually using the Mac → Linux LAN setup, plus a quality-of-life cleanup on the pi update banner. Minor version bump because three of the four changes are new behavior, all backwards-compatible.

package/README.md

@@ -2,6 +2,8 @@
 
 **A coding agent tuned for small local models, built on top of [pi](https://pi.dev).**
 
+![little-coder startup view](docs/assets/startup.svg)
+
 The research story behind all this — why scaffold–model fit matters, how a 9.7 B Qwen beat frontier entries on Aider Polyglot, and what the load-bearing mechanisms actually do — is written up on Substack: **[*Honey, I Shrunk the Coding Agent*](https://open.substack.com/pub/itayinbarr/p/honey-i-shrunk-the-coding-agent)**. Start there if you want the "why"; stay here for the "how".
 
 ## How it relates to pi
@@ -290,9 +292,10 @@ The benchmarks harness (`benchmarks/`) is dev-only and not shipped with the npm
 little-coder/
 ├── .pi/
 │   ├── settings.json               # per-model profiles + benchmark_overrides (terminal_bench, gaia)
-│   └── extensions/                 # 20 TypeScript extensions, auto-discovered by pi
+│   └── extensions/                 # 21 TypeScript extensions, auto-discovered by pi
+│       ├── branding/               # little-coder startup header + terminal title (replaces pi's built-in)
 │       ├── llama-cpp-provider/     # data-driven provider registration from models.json — ships llamacpp, ollama, lmstudio (+ user override file)
-│       ├── write-guard/            # Write refuses on existing files — the whitepaper invariant
+│       ├── write-guard/            # Write refuses on existing files; rewrites root-bare /foo.md paths to cwd
 │       ├── extra-tools/            # glob, webfetch, websearch (pi ships grep/find)
 │       ├── skill-inject/           # per-turn tool-skill selection (error > recency > intent)
 │       ├── knowledge-inject/       # algorithm cheat-sheet scoring (word=1.0, bigram=2.0, threshold=2.0)

package/bin/little-coder.mjs

@@ -4,7 +4,15 @@
 // custom extension wired in — works from any working directory.
 
 import { spawn } from "node:child_process";
-import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  statSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { checkForUpdate } from "./update-check.mjs";
@@ -98,7 +106,50 @@ if (process.env.PI_SKIP_VERSION_CHECK === undefined) {
   process.env.PI_SKIP_VERSION_CHECK = "1";
 }
 
-// ---- 8. Spawn pi in the user's cwd ----
+// ---- 8. Force pi's global quietStartup so the loaded-resources block stays hidden ----
+// Pi's interactive mode dumps an [Extensions] / [Skills] / [Prompts] block on
+// every launch unless `quietStartup: true` is set in its global settings
+// (~/.pi/agent/settings.json). Our shipped .pi/settings.json doesn't reach pi
+// because pi reads from <cwd>/.pi/settings.json (project) or <agentDir>/settings.json
+// (global), neither of which is our npm-installed package dir. So the launcher
+// non-destructively merges quietStartup: true into the user's actual global
+// settings file. Existing keys are preserved. To see the full inventory, run
+// `little-coder --verbose` — pi's verbose flag overrides quietStartup.
+try {
+  const agentDirEnv = process.env.PI_CODING_AGENT_DIR;
+  let agentDir;
+  if (agentDirEnv && agentDirEnv.trim().length > 0) {
+    agentDir = agentDirEnv === "~"
+      ? homedir()
+      : agentDirEnv.startsWith("~/")
+        ? homedir() + agentDirEnv.slice(1)
+        : agentDirEnv;
+  } else {
+    agentDir = join(homedir(), ".pi", "agent");
+  }
+  mkdirSync(agentDir, { recursive: true });
+  const globalSettingsPath = join(agentDir, "settings.json");
+  let globalSettings = {};
+  if (existsSync(globalSettingsPath)) {
+    try {
+      const parsed = JSON.parse(readFileSync(globalSettingsPath, "utf-8"));
+      if (parsed && typeof parsed === "object") globalSettings = parsed;
+    } catch {
+      // Corrupted JSON — start fresh rather than throw. Pi would have rejected it too.
+      globalSettings = {};
+    }
+  }
+  if (globalSettings.quietStartup !== true) {
+    globalSettings.quietStartup = true;
+    writeFileSync(globalSettingsPath, JSON.stringify(globalSettings, null, 2));
+  }
+} catch {
+  // Best-effort. If we can't write the settings (read-only HOME, etc.) pi
+  // falls back to its built-in defaults — the [Extensions] block will show
+  // but everything else still works.
+}
+
+// ---- 9. Spawn pi in the user's cwd ----
 const [spawnCmd, spawnArgs] = isWindows
   ? ["cmd.exe", ["/c", piBin, ...piArgs]]
   : [piBin, piArgs];

package/package.json

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