pi-minimal 0.1.0

package/.github/workflows/ci.yml

@@ -0,0 +1,25 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22.19.0
+          cache: npm
+      - run: npm ci
+      - run: npm run lint
+      - run: npm run typecheck
+      - run: npm test
+      - run: npm run build
+      - run: git diff --exit-code -- dist

package/.github/workflows/publish.yml

@@ -0,0 +1,29 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+permissions:
+  contents: read
+  id-token: write
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    environment: npm
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 22.19.0
+          registry-url: https://registry.npmjs.org
+          cache: npm
+      - run: npm ci
+      - run: npm run lint
+      - run: npm test
+      - run: npm run build
+      - run: git diff --exit-code -- dist
+      - run: npm publish --access public
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 raviy06
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# pi-minimal
+
+A Pi coding-agent package.
+
+## Requirements
+
+- Node.js `>=22.19.0`
+- Pi `>=0.84.4`
+
+No other Pi extension is required. Pi supplies the peer packages used by this extension.
+
+Optional integrations:
+
+- `pi-gauntlet`: supplies the phase and task data shown in the footer. Its widgets are hidden by default.
+- Herdr: sibling status appears only when Pi is running inside Herdr.
+
+## Installation
+
+```bash
+pi install git:github.com/raviy06/pi-minimal
+```
+
+Do not load this package beside the live `grok-chrome` extension. Disable or remove `grok-chrome` before enabling `pi-minimal`.
+
+## Configuration
+
+The package loads JSON in this order:
+
+1. Built-in defaults
+2. Global: `~/.pi/agent/pi-minimal.json` (or `$PI_CODING_AGENT_DIR/pi-minimal.json` when the agent directory is overridden)
+3. Project: `.pi/pi-minimal.json` in the current working directory, only when the project is trusted
+
+Project values override global values. A missing file, omitted key, or invalid value does not override the lower-precedence value.
+
+The only supported key is `hideGauntletWidgets`. It defaults to `true`.
+
+```json
+{ "hideGauntletWidgets": true }
+```

package/dist/activity.js

@@ -0,0 +1,12 @@
+export function rowIsRunning(context) {
+    if (context.isError)
+        return false;
+    if (context.state?.done)
+        return false;
+    if (context.isPartial === false)
+        return false;
+    return true;
+}
+export function activityBullet(running, frame) {
+    return running && frame === 1 ? "◇" : "◆";
+}

package/dist/chrome.js

@@ -0,0 +1 @@
+export const CHROME_MARGIN = 1;

package/dist/config.js

@@ -0,0 +1,45 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { CONFIG_DIR_NAME } from "@earendil-works/pi-coding-agent";
+const DEFAULTS = {
+    hideGauntletWidgets: true,
+};
+export function loadPiMinimalConfig(options) {
+    const config = { ...DEFAULTS };
+    applyLayer(config, join(options.agentDir, "pi-minimal.json"));
+    if (options.projectTrusted) {
+        applyLayer(config, join(options.cwd, CONFIG_DIR_NAME, "pi-minimal.json"));
+    }
+    return config;
+}
+function applyLayer(config, path) {
+    let text;
+    try {
+        text = readFileSync(path, "utf8");
+    }
+    catch {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        console.error(`pi-minimal: invalid JSON in ${path}`);
+        return;
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+        console.error(`pi-minimal: expected an object in ${path}`);
+        return;
+    }
+    const record = parsed;
+    if (!Object.hasOwn(record, "hideGauntletWidgets")) {
+        return;
+    }
+    const value = record.hideGauntletWidgets;
+    if (typeof value !== "boolean") {
+        console.error(`pi-minimal: hideGauntletWidgets must be a boolean in ${path}`);
+        return;
+    }
+    config.hideGauntletWidgets = value;
+}

package/dist/cwd.js

@@ -0,0 +1,103 @@
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import path from "node:path";
+import { CHROME_MARGIN } from "./chrome.js";
+function formatCwd(cwd) {
+    const home = process.env.HOME || process.env.USERPROFILE || "";
+    if (!home)
+        return cwd;
+    const resolved = path.resolve(cwd);
+    const rel = path.relative(path.resolve(home), resolved);
+    if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+        return rel ? `~/${rel}` : "~";
+    }
+    return cwd;
+}
+function formatTokens(n) {
+    if (n < 1000)
+        return String(n);
+    if (n < 10000)
+        return `${(n / 1000).toFixed(1)}K`;
+    if (n < 1e6)
+        return `${Math.round(n / 1000)}K`;
+    if (n < 1e7)
+        return `${(n / 1e6).toFixed(1)}M`;
+    return `${Math.round(n / 1e6)}M`;
+}
+function modelIcon(id) {
+    const s = id.toLowerCase();
+    if (s.includes("grok"))
+        return "✦";
+    if (s.includes("claude") ||
+        s.includes("fable") ||
+        s.includes("sonnet") ||
+        s.includes("opus") ||
+        s.includes("haiku")) {
+        return "✳";
+    }
+    if (s.includes("gpt") || s.includes("codex"))
+        return "◈";
+    return "◆";
+}
+function shortModel(id) {
+    return (id.split("/").pop() || id).replace(/^claude-/, "");
+}
+function thinkingColor(level) {
+    if (level === "high" || level === "xhigh" || level === "max")
+        return "warning";
+    if (level === "medium")
+        return "accent";
+    return "dim";
+}
+function meter(percent, fill, empty) {
+    const n = 8;
+    const filled = Math.max(0, Math.min(n, Math.round((percent / 100) * n)));
+    return fill.repeat(filled) + empty.repeat(n - filled);
+}
+function splitRow(left, right, width) {
+    let L = left;
+    let R = right;
+    while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(R) > 0) {
+        R = truncateToWidth(R, Math.max(0, visibleWidth(R) - 1), "");
+    }
+    while (visibleWidth(L) + 1 + visibleWidth(R) > width && visibleWidth(L) > 0) {
+        L = truncateToWidth(L, Math.max(0, visibleWidth(L) - 1), "");
+    }
+    const gap = Math.max(1, width - visibleWidth(L) - visibleWidth(R));
+    return L + " ".repeat(gap) + R;
+}
+export function installCwd(ctx) {
+    ctx.ui.setWidget("tw-cwd", (_tui, theme) => ({
+        invalidate() { },
+        render(width) {
+            const inner = Math.max(8, width - CHROME_MARGIN * 2);
+            const id = ctx.model?.id || "no-model";
+            const icon = theme.fg("accent", modelIcon(id));
+            const name = theme.fg("text", shortModel(id));
+            const usage = ctx.getContextUsage?.();
+            const window = usage?.contextWindow || ctx.model?.contextWindow;
+            const used = usage?.tokens;
+            let tokenStr = theme.fg("dim", "?/?");
+            let bar = theme.fg("dim", "░░░░░░░░");
+            let pctStr = theme.fg("dim", "?%");
+            if (typeof used === "number" && window) {
+                const pct = Math.max(0, Math.min(100, Math.round((used / window) * 100)));
+                tokenStr = theme.fg("dim", `${formatTokens(used)}/${formatTokens(window)}`);
+                const hot = pct >= 85;
+                bar = meter(pct, theme.fg(hot ? "warning" : "accent", "█"), theme.fg("dim", "░"));
+                pctStr = theme.fg(hot ? "warning" : "muted", `${pct}%`);
+            }
+            else if (used === null && window) {
+                tokenStr = theme.fg("dim", `?/${formatTokens(window)}`);
+            }
+            const thinking = ctx.thinkingLevel || "";
+            const think = thinking ? theme.fg(thinkingColor(thinking), thinking) : "";
+            const midot = theme.fg("dim", " · ");
+            const left = [`${icon} ${name}`, tokenStr, `${bar} ${pctStr}`, think]
+                .filter(Boolean)
+                .join(midot);
+            const right = ctx.cwd ? theme.fg("accent", formatCwd(ctx.cwd)) : "";
+            const row = splitRow(left, right, inner);
+            return [`${" ".repeat(CHROME_MARGIN)}${row}`];
+        },
+    }), { placement: "aboveEditor" });
+}

package/dist/footer.js

@@ -0,0 +1,46 @@
+import { keyHint } from "@earendil-works/pi-coding-agent";
+import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { CHROME_MARGIN } from "./chrome.js";
+import { formatTrackerLines } from "./tracker.js";
+function statusColor(status) {
+    if (status === "idle" || status === "done")
+        return "success";
+    if (status === "working")
+        return "accent";
+    if (status === "blocked")
+        return "error";
+    return "muted";
+}
+export function installFooter(ctx, getSiblings) {
+    ctx.ui.setFooter((tui, theme, footerData) => {
+        const unsub = footerData.onBranchChange(() => tui.requestRender());
+        return {
+            dispose: unsub,
+            invalidate() { },
+            render(width) {
+                const send = keyHint("tui.input.submit", "send");
+                const think = keyHint("app.thinking.cycle", "thinking");
+                const left = [send, think].filter(Boolean).join("  ·  ");
+                const siblings = getSiblings();
+                let right = "";
+                if (siblings && siblings.length > 0) {
+                    right = siblings
+                        .map((s) => {
+                        const name = theme.fg("text", s.name);
+                        const st = theme.fg(statusColor(s.status), s.status);
+                        return `${name} ${st}`;
+                    })
+                        .join(theme.fg("dim", "  ·  "));
+                }
+                const inner = Math.max(8, width - CHROME_MARGIN * 2);
+                const pad = Math.max(1, inner - visibleWidth(left) - visibleWidth(right));
+                const line = truncateToWidth(left + " ".repeat(pad) + right, inner, "");
+                const out = [`${" ".repeat(CHROME_MARGIN)}${line}`];
+                for (const extra of formatTrackerLines(ctx, theme)) {
+                    out.push(`${" ".repeat(CHROME_MARGIN)}${truncateToWidth(extra, inner, "")}`);
+                }
+                return out;
+            },
+        };
+    });
+}

package/dist/header.js

@@ -0,0 +1,14 @@
+import { Text } from "@earendil-works/pi-tui";
+export function installHeader(ctx) {
+    ctx.ui.setHeader(() => {
+        const text = new Text("", 0, 0);
+        return {
+            render() {
+                return text.render(1);
+            },
+            invalidate() {
+                text.invalidate();
+            },
+        };
+    });
+}

package/dist/herdr.js

@@ -0,0 +1,44 @@
+function parseJson(stdout) {
+    return JSON.parse(stdout);
+}
+export function parseAgentList(stdout) {
+    const data = parseJson(stdout);
+    const rows = data.result?.agents;
+    if (!Array.isArray(rows))
+        throw new Error("invalid herdr agent list");
+    return rows.map((row) => ({
+        agent: String(row.agent ?? ""),
+        agent_status: String(row.agent_status ?? ""),
+        pane_id: String(row.pane_id ?? ""),
+        tab_id: String(row.tab_id ?? ""),
+    }));
+}
+export function parseTabList(stdout) {
+    const data = parseJson(stdout);
+    const rows = data.result?.tabs;
+    if (!Array.isArray(rows))
+        throw new Error("invalid herdr tab list");
+    return rows.map((row) => ({
+        label: String(row.label ?? ""),
+        tab_id: String(row.tab_id ?? ""),
+    }));
+}
+export function listSiblings(agents, tabs, selfPane, selfTab) {
+    if (!selfPane && !selfTab)
+        return undefined;
+    const labels = new Map(tabs.map((t) => [t.tab_id, t.label]));
+    const parts = [];
+    for (const agent of agents) {
+        if (selfPane && agent.pane_id === selfPane)
+            continue;
+        if (!selfPane && selfTab && agent.tab_id === selfTab)
+            continue;
+        const name = labels.get(agent.tab_id) || agent.agent;
+        if (!name)
+            continue;
+        parts.push({ name, status: agent.agent_status });
+    }
+    if (parts.length === 0)
+        return undefined;
+    return parts;
+}

package/dist/index.js

@@ -0,0 +1,155 @@
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { loadPiMinimalConfig } from "./config.js";
+import { installHeader } from "./header.js";
+import { installFooter } from "./footer.js";
+import { installCwd } from "./cwd.js";
+import { listSiblings, parseAgentList, parseTabList } from "./herdr.js";
+import { hideGauntletWidgets } from "./tracker.js";
+import { stopLiveWatch, wrapBuiltinTools } from "./tools.js";
+import { applyReclaim, reclaimPolicy } from "./reclaim.js";
+import { installWorkingStatus } from "./working-status.js";
+export default function piMinimalExtension(pi) {
+    const stopWorkingStatus = installWorkingStatus(pi);
+    let fastTimer;
+    let slowTimer;
+    let stealTimer;
+    let inFlight;
+    let siblings;
+    let generation = 0;
+    let hideWidgets = true;
+    const stopTimers = () => {
+        if (fastTimer)
+            clearInterval(fastTimer);
+        if (slowTimer)
+            clearInterval(slowTimer);
+        if (stealTimer)
+            clearInterval(stealTimer);
+        fastTimer = undefined;
+        slowTimer = undefined;
+        stealTimer = undefined;
+        inFlight?.abort();
+        inFlight = undefined;
+    };
+    const scheduleFast = (ctx) => {
+        if (fastTimer)
+            return;
+        if (slowTimer)
+            clearInterval(slowTimer);
+        slowTimer = undefined;
+        fastTimer = setInterval(() => {
+            void probe(ctx);
+        }, 2000);
+    };
+    const scheduleSlow = (ctx) => {
+        if (slowTimer)
+            return;
+        if (fastTimer)
+            clearInterval(fastTimer);
+        fastTimer = undefined;
+        slowTimer = setInterval(() => {
+            void probe(ctx);
+        }, 10000);
+    };
+    const probe = async (ctx) => {
+        if (process.env.HERDR_ENV !== "1")
+            return;
+        if (inFlight)
+            return;
+        const ac = new AbortController();
+        const gen = generation;
+        inFlight = ac;
+        try {
+            const agentRun = await pi.exec("herdr", ["agent", "list"], {
+                timeout: 3000,
+                signal: ac.signal,
+            });
+            if (generation !== gen)
+                return;
+            const tabRun = await pi.exec("herdr", ["tab", "list"], {
+                timeout: 3000,
+                signal: ac.signal,
+            });
+            if (generation !== gen)
+                return;
+            if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
+                siblings = undefined;
+                scheduleSlow(ctx);
+                return;
+            }
+            siblings = listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), process.env.HERDR_PANE_ID, process.env.HERDR_TAB_ID);
+            if (siblings)
+                scheduleFast(ctx);
+            else
+                scheduleSlow(ctx);
+        }
+        catch {
+            if (generation !== gen)
+                return;
+            siblings = undefined;
+            scheduleSlow(ctx);
+        }
+        finally {
+            if (inFlight === ac)
+                inFlight = undefined;
+        }
+    };
+    const hideForeignChrome = (ctx, reason) => {
+        if (ctx.mode !== "tui")
+            return;
+        applyReclaim(reason, ctx.ui, {
+            widgets: () => {
+                if (hideWidgets)
+                    hideGauntletWidgets(ctx);
+            },
+            chrome: () => {
+                installHeader(ctx);
+                installFooter(ctx, () => siblings);
+            },
+        });
+    };
+    const pinChrome = (ctx, reason) => {
+        hideForeignChrome(ctx, reason);
+        if (ctx.mode !== "tui" || !reclaimPolicy(reason).reinstallChrome)
+            return;
+        ctx.ui.setWidget("tw-cwd", undefined);
+        installCwd(ctx);
+    };
+    pi.on("session_start", async (_event, ctx) => {
+        if (ctx.mode !== "tui")
+            return;
+        const config = loadPiMinimalConfig({
+            agentDir: getAgentDir(),
+            cwd: ctx.cwd,
+            projectTrusted: ctx.isProjectTrusted(),
+        });
+        hideWidgets = config.hideGauntletWidgets;
+        installHeader(ctx);
+        installFooter(ctx, () => siblings);
+        installCwd(ctx);
+        wrapBuiltinTools(pi, ctx);
+        pinChrome(ctx, "session_start");
+        ctx.ui.setHiddenThinkingLabel("◆ Thought");
+        ctx.ui.setWorkingIndicator();
+        setTimeout(() => pinChrome(ctx, "session_settle"), 0);
+        setTimeout(() => pinChrome(ctx, "session_settle"), 50);
+        if (!stealTimer) {
+            stealTimer = setInterval(() => hideForeignChrome(ctx, "interval"), 200);
+        }
+        if (process.env.HERDR_ENV === "1") {
+            await probe(ctx);
+        }
+    });
+    pi.on("turn_end", (_event, ctx) => {
+        pinChrome(ctx, "turn_end");
+    });
+    pi.on("tool_execution_end", (_event, ctx) => {
+        pinChrome(ctx, "tool_execution_end");
+    });
+    pi.on("session_shutdown", async () => {
+        stopTimers();
+        stopWorkingStatus();
+        stopLiveWatch();
+        generation += 1;
+        siblings = undefined;
+    });
+}

package/dist/live-watch.js

@@ -0,0 +1,52 @@
+export function createLiveWatch(intervalMs = 400) {
+    let frame = 0;
+    let timer;
+    const invalidators = new Map();
+    const tick = () => {
+        frame = frame === 0 ? 1 : 0;
+        const snapshot = [...invalidators.values()];
+        for (const invalidate of snapshot) {
+            try {
+                invalidate();
+            }
+            catch {
+                // A single renderer failure must not stop the shared activity frame.
+            }
+        }
+    };
+    return {
+        watch(id, invalidate) {
+            if (!id)
+                return;
+            invalidators.set(id, invalidate);
+            if (!timer)
+                timer = setInterval(tick, intervalMs);
+        },
+        unwatch(id) {
+            if (!id)
+                return;
+            invalidators.delete(id);
+            if (invalidators.size === 0 && timer) {
+                clearInterval(timer);
+                timer = undefined;
+            }
+        },
+        has(id) {
+            return Boolean(id) && invalidators.has(id);
+        },
+        stop() {
+            if (timer)
+                clearInterval(timer);
+            timer = undefined;
+            invalidators.clear();
+            frame = 0;
+        },
+        tick,
+        get frame() {
+            return frame;
+        },
+        get size() {
+            return invalidators.size;
+        },
+    };
+}

package/dist/reclaim.js

@@ -0,0 +1,19 @@
+export function reclaimPolicy(reason) {
+    if (reason === "session_start") {
+        return { resetEditor: true, reinstallChrome: true };
+    }
+    if (reason === "interval") {
+        return { resetEditor: false, reinstallChrome: false };
+    }
+    // session_settle / turn_end / tool_execution_end: restore chrome, keep editor
+    return { resetEditor: false, reinstallChrome: true };
+}
+export function applyReclaim(reason, ui, install) {
+    const policy = reclaimPolicy(reason);
+    install.widgets();
+    if (policy.resetEditor)
+        ui.setEditorComponent(undefined);
+    if (policy.reinstallChrome)
+        install.chrome();
+    return policy;
+}

package/dist/tool-rows.js

@@ -0,0 +1,34 @@
+let activityGroup;
+export function resetActivityGroup() {
+    activityGroup = undefined;
+}
+export function shortName(path) {
+    const parts = path.split("/").filter(Boolean);
+    if (parts.length <= 1)
+        return path || "";
+    return parts.slice(-2).join("/");
+}
+export function toolItem(kind, args) {
+    if (kind === "bash") {
+        const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : "";
+        return command || "bash";
+    }
+    if (kind === "grep" || kind === "find") {
+        return typeof args?.pattern === "string" && args.pattern ? args.pattern : kind;
+    }
+    const path = (typeof args?.path === "string" && args.path) ||
+        (typeof args?.file_path === "string" && args.file_path) ||
+        (typeof args?.target_directory === "string" && args.target_directory) ||
+        "";
+    return path ? shortName(path) : kind;
+}
+export function nextGroupedRow(verb, item, id) {
+    if (activityGroup && activityGroup.verb === verb) {
+        activityGroup.seen.add(id);
+        if (id === activityGroup.leadId)
+            return { header: verb, item };
+        return { header: undefined, item };
+    }
+    activityGroup = { verb, leadId: id, seen: new Set([id]) };
+    return { header: verb, item };
+}