v1.9.3: LITTLE_CODER_EXTRA_EXTENSIONS env var for third-party pi extensions (#46)

The launcher passes --no-extensions to pi, so a globally-installed pi
package (pi-ponytail, etc) doesn't reach the running little-coder.
Until now the supported workaround was `little-coder -e <abs path>`
per launch, or dropping a wrapper into <pkgRoot>/.pi/extensions/ —
the latter gets wiped on upgrade.

New env var LITTLE_CODER_EXTRA_EXTENSIONS: path-delimited list of
extra extensions to layer on top of the bundled set. Each entry can
be a direct file or a directory containing index.ts / index.js;
~/ is expanded; missing paths emit a one-line warning and are
skipped so a typo doesn't kill the session.

Parsing rules live in bin/extras.mjs so they're unit-testable in
isolation (9 cases). Launcher integration verified end-to-end —
warning prints for a bad path; valid paths pass through silently as
--extension <entry> flags to pi.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: Itay Inbar

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.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

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:
 

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 };
+}

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 });
+    }
+  });
+});

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.json

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