pi-minimal 0.4.0 → 0.6.0

package/dist/edit-diff.js

@@ -0,0 +1,74 @@
+import { diffWords } from "diff";
+/** The edit tool's `details.diff`, when present and non-empty. */
+export function editDiffText(result) {
+    const details = result?.details;
+    return typeof details?.diff === "string" && details.diff.trim() ? details.diff : undefined;
+}
+/** pi's edit diff lines: "+123 content", "-123 content", " 123 context"; anything else (e.g. "...") is a separator. */
+function parseDiffLine(line) {
+    const match = /^([+\- ])(\s*\d*) (.*)$/.exec(line);
+    if (!match)
+        return undefined;
+    return { prefix: match[1], lineNum: match[2], content: match[3].replace(/\t/g, "   ") };
+}
+/** Word-level diff of a 1:1 replacement; changed tokens are inverted, leading indentation is left alone, as in pi. */
+function highlightPair(removed, added, theme) {
+    let out = { removed: "", added: "" };
+    let firstRemoved = true;
+    let firstAdded = true;
+    for (const part of diffWords(removed, added)) {
+        if (part.removed || part.added) {
+            const key = part.removed ? "removed" : "added";
+            let value = part.value;
+            if (part.removed ? firstRemoved : firstAdded) {
+                const ws = /^(\s*)/.exec(value)?.[1] ?? "";
+                value = value.slice(ws.length);
+                out = { ...out, [key]: out[key] + ws };
+                if (part.removed)
+                    firstRemoved = false;
+                else
+                    firstAdded = false;
+            }
+            if (value)
+                out = { ...out, [key]: out[key] + theme.inverse(value) };
+        }
+        else {
+            out = { removed: out.removed + part.value, added: out.added + part.value };
+        }
+    }
+    return out;
+}
+/** Colours pi's edit diff like pi does: theme diff colours per line, inverse on changed tokens of single-line replacements. */
+export function colorDiffLines(lines, theme) {
+    const out = [];
+    for (let i = 0; i < lines.length;) {
+        const parsed = parseDiffLine(lines[i]);
+        if (!parsed) {
+            out.push(theme.fg("toolDiffContext", lines[i]));
+            i++;
+            continue;
+        }
+        if (parsed.prefix === " ") {
+            out.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${parsed.content}`));
+            i++;
+            continue;
+        }
+        const removed = [];
+        const added = [];
+        for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "-"; p = parseDiffLine(lines[++i] ?? ""))
+            removed.push(p);
+        for (let p = parseDiffLine(lines[i] ?? ""); p?.prefix === "+"; p = parseDiffLine(lines[++i] ?? ""))
+            added.push(p);
+        if (removed.length === 1 && added.length === 1) {
+            const pair = highlightPair(removed[0].content, added[0].content, theme);
+            out.push(theme.fg("toolDiffRemoved", `-${removed[0].lineNum} ${pair.removed}`));
+            out.push(theme.fg("toolDiffAdded", `+${added[0].lineNum} ${pair.added}`));
+            continue;
+        }
+        for (const line of removed)
+            out.push(theme.fg("toolDiffRemoved", `-${line.lineNum} ${line.content}`));
+        for (const line of added)
+            out.push(theme.fg("toolDiffAdded", `+${line.lineNum} ${line.content}`));
+    }
+    return out;
+}

package/dist/footer-contribution-events.js

@@ -3,6 +3,8 @@ export const FOOTER_EVENTS = {
     ready: "pi-minimal:footer:v1:ready",
     unavailable: "pi-minimal:footer:v1:unavailable",
 };
+/** Slot names on the wire. `summary` is the legacy name of the plan slot and stays accepted. */
+export const FOOTER_SLOTS = ["activity", "plan", "summary"];
 /** Bind once per session, not once per footer mount. Trusted in-process protocol. */
 export function bindFooterContributionEvents(events, registry, sessionId, mode) {
     registry.reset(mode === "tui" ? sessionId : null);
@@ -13,15 +15,15 @@ export function bindFooterContributionEvents(events, registry, sessionId, mode)
         // A different host may have answered first. Never overwrite its result.
         if (request.result !== undefined)
             return;
-        if (request.version !== 1 || (request.slot !== "activity" && request.slot !== "summary"))
+        if (request.version !== 1 || !FOOTER_SLOTS.includes(request.slot))
             request.result = { ok: false, code: "invalid" };
         else if (mode !== "tui")
             request.result = { ok: false, code: "not-tui" };
         else
-            request.result = request.slot === "summary" ? registry.registerPlan(request) : registry.register(request);
+            request.result = request.slot === "activity" ? registry.register(request) : registry.registerPlan(request);
     });
     if (mode === "tui")
-        events.emit(FOOTER_EVENTS.ready, { version: 1, sessionId, slots: ["activity", "summary"] });
+        events.emit(FOOTER_EVENTS.ready, { version: 1, sessionId, slots: [...FOOTER_SLOTS] });
     let disposed = false;
     return () => {
         if (disposed)

package/dist/footer-contributions.js

@@ -60,7 +60,8 @@ function normalizeSnapshot(input) {
 }
 function createFooterSlot(normalize, initialSessionId) {
     let sessionId = initialSessionId;
-    let owner;
+    // The registrant's `owner` string is a display identity; this symbol is the actual authority to publish.
+    let ownerToken;
     let snapshot;
     const observers = new Set();
     const notify = () => {
@@ -76,7 +77,7 @@ function createFooterSlot(normalize, initialSessionId) {
         subscribe(observer) { observers.add(observer); return () => { observers.delete(observer); }; },
         reset(nextSessionId) {
             sessionId = nextSessionId;
-            owner = undefined;
+            ownerToken = undefined;
             snapshot = undefined;
             notify();
         },
@@ -85,13 +86,13 @@ function createFooterSlot(normalize, initialSessionId) {
                 return { ok: false, code: "invalid" };
             if (sessionId === null || input.sessionId !== sessionId)
                 return { ok: false, code: "wrong-session" };
-            if (owner)
+            if (ownerToken)
                 return { ok: false, code: "occupied" };
             const token = Symbol(input.owner);
-            owner = token;
+            ownerToken = token;
             return { ok: true, registration: {
                     publish(input) {
-                        if (owner !== token)
+                        if (ownerToken !== token)
                             return { ok: false, code: "disposed" };
                         const next = normalize(input);
                         if (!next)
@@ -103,9 +104,9 @@ function createFooterSlot(normalize, initialSessionId) {
                         return { ok: true };
                     },
                     dispose() {
-                        if (owner !== token)
+                        if (ownerToken !== token)
                             return;
-                        owner = undefined;
+                        ownerToken = undefined;
                         snapshot = undefined;
                         notify();
                     },
@@ -115,16 +116,17 @@ function createFooterSlot(normalize, initialSessionId) {
 }
 export function createFooterContributions(initialSessionId = null) {
     const activity = createFooterSlot(normalizeSnapshot, initialSessionId);
-    const summary = createFooterSlot(normalizePlanSnapshot, initialSessionId);
+    // The plan slot; "summary" is its legacy wire name.
+    const plan = createFooterSlot(normalizePlanSnapshot, initialSessionId);
     return {
         read: activity.read,
-        readPlan: summary.read,
+        readPlan: plan.read,
         register: activity.register,
-        registerPlan: summary.register,
+        registerPlan: plan.register,
         subscribe(observer) {
-            const offActivity = activity.subscribe(observer), offSummary = summary.subscribe(observer);
-            return () => { offActivity(); offSummary(); };
+            const offActivity = activity.subscribe(observer), offPlan = plan.subscribe(observer);
+            return () => { offActivity(); offPlan(); };
         },
-        reset(sessionId) { activity.reset(sessionId); summary.reset(sessionId); },
+        reset(sessionId) { activity.reset(sessionId); plan.reset(sessionId); },
     };
 }

package/dist/footer.js

@@ -1,6 +1,7 @@
 import { keyHint } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth } from "@earendil-works/pi-tui";
 import * as chrome from "./chrome.js";
+import { splitRow } from "./cwd.js";
 import { formatTrackerLines } from "./tracker.js";
 import { activityNeedsAnimation, renderFooterActivity } from "./footer-activity.js";
 import { createLiveWatch } from "./live-watch.js";
@@ -45,12 +46,16 @@ export function installFooter(ctx, sources, contributions) {
         const update = () => { syncAnimation(); redraw(); };
         const unsub = footerData.onBranchChange(redraw);
         const unsubscribeActivity = contributions?.subscribe(update);
+        const unsubscribePrs = sources.onPrsChange?.(redraw);
+        const unsubscribeBackground = sources.onBackgroundChange?.(redraw);
         stopMount = () => {
             if (disposed)
                 return;
             disposed = true;
             unsub();
             unsubscribeActivity?.();
+            unsubscribePrs?.();
+            unsubscribeBackground?.();
             live.stop();
         };
         update();
@@ -65,9 +70,16 @@ export function installFooter(ctx, sources, contributions) {
                     keyHint("app.thinking.cycle", "thinking"),
                     keyHint("app.tools.expand", "expand tools"),
                 ].filter(Boolean));
-                if (hints.length > 0) {
-                    const line = theme.fg("dim", hints.join("  ·  "));
-                    out.push(`${" ".repeat(margin())}${truncateToWidth(line, inner, "")}`);
+                // Left: hints (idle only) then the background count (always). Right: PR chips whenever
+                // there are any. The chips are dropped before the left side when the line is too narrow.
+                const background = sources.background?.();
+                const left = [hints.length > 0 ? theme.fg("dim", hints.join("  ·  ")) : "", background ? theme.fg("warning", background) : ""]
+                    .filter(Boolean)
+                    .join(theme.fg("dim", "  ·  "));
+                const prs = sources.prs?.(theme);
+                if (left || prs) {
+                    const line = prs ? splitRow(left, [prs], inner) : truncateToWidth(left, inner, "");
+                    out.push(`${" ".repeat(margin())}${line}`);
                 }
                 const activityWidth = Math.max(0, width - margin() * 2);
                 const plan = renderFooterPlan(contributions?.readPlan(), activityWidth, theme);

package/dist/git-state.js

@@ -21,34 +21,50 @@ export function createGitState(pi, cwd, minIntervalMs = 5000) {
     let state;
     let lastRun = 0;
     let inFlight;
+    let disposed = false;
     const listeners = new Set();
+    const notify = () => {
+        for (const listener of listeners) {
+            try {
+                listener();
+            }
+            catch {
+                // One listener's failure must not starve the others.
+            }
+        }
+    };
     const refresh = (force = false) => {
+        if (disposed)
+            return Promise.resolve();
         const now = Date.now();
         if (inFlight)
             return inFlight;
         if (!force && now - lastRun < minIntervalMs)
             return Promise.resolve();
         lastRun = now;
+        // Read the directory once so both commands describe the same tree even if cwd changes mid-refresh.
+        const dir = cwd();
         inFlight = (async () => {
+            let next;
             try {
-                const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: cwd(), timeout: 2000 });
-                if (branchRun.code !== 0) {
-                    state = undefined;
-                    return;
+                const branchRun = await pi.exec("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd: dir, timeout: 2000 });
+                if (branchRun.code === 0) {
+                    const branch = parseBranch(branchRun.stdout);
+                    const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: dir, timeout: 3000 });
+                    next = { branch, dirty: statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined };
                 }
-                const branch = parseBranch(branchRun.stdout);
-                const statusRun = await pi.exec("git", ["status", "--porcelain"], { cwd: cwd(), timeout: 3000 });
-                const dirty = statusRun.code === 0 ? parsePorcelain(statusRun.stdout) : undefined;
-                state = { branch, dirty };
             }
             catch {
-                state = undefined;
+                next = undefined;
             }
             finally {
                 inFlight = undefined;
-                for (const listener of listeners)
-                    listener();
             }
+            // A result that lands after dispose belongs to a session that no longer exists.
+            if (disposed)
+                return;
+            state = next;
+            notify();
         })();
         return inFlight;
     };
@@ -59,5 +75,9 @@ export function createGitState(pi, cwd, minIntervalMs = 5000) {
             listeners.add(listener);
             return () => listeners.delete(listener);
         },
+        dispose() {
+            disposed = true;
+            listeners.clear();
+        },
     };
 }

package/dist/herdr.js

@@ -1,3 +1,4 @@
+import { createListeners } from "./listeners.js";
 function parseJson(stdout) {
     return JSON.parse(stdout);
 }
@@ -42,3 +43,80 @@ export function listSiblings(agents, tabs, selfPane, selfTab) {
         return undefined;
     return parts;
 }
+const HERDR_FAST_MS = 2000;
+const HERDR_SLOW_MS = 10000;
+const HERDR_EXEC_TIMEOUT_MS = 3000;
+/**
+ * Polls `herdr agent list` + `herdr tab list`: every 2 s while siblings are visible, every 10 s
+ * otherwise or after a failure. Probes once immediately.
+ */
+export function createHerdrSiblings(pi, env = process.env) {
+    let alive = true;
+    let siblings;
+    let timer;
+    let period = 0;
+    let inFlight;
+    const listeners = createListeners();
+    const set = (next) => {
+        const changed = JSON.stringify(next) !== JSON.stringify(siblings);
+        siblings = next;
+        if (changed)
+            listeners.notify();
+    };
+    const schedule = (periodMs) => {
+        if (!alive || period === periodMs)
+            return;
+        if (timer)
+            clearInterval(timer);
+        period = periodMs;
+        timer = setInterval(() => { void probe(); }, periodMs);
+    };
+    const probe = async () => {
+        if (!alive || inFlight)
+            return;
+        const ac = new AbortController();
+        inFlight = ac;
+        try {
+            const agentRun = await pi.exec("herdr", ["agent", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal });
+            if (!alive)
+                return;
+            const tabRun = await pi.exec("herdr", ["tab", "list"], { timeout: HERDR_EXEC_TIMEOUT_MS, signal: ac.signal });
+            if (!alive)
+                return;
+            if (agentRun.code !== 0 || tabRun.code !== 0 || agentRun.killed || tabRun.killed) {
+                set(undefined);
+                schedule(HERDR_SLOW_MS);
+                return;
+            }
+            set(listSiblings(parseAgentList(agentRun.stdout), parseTabList(tabRun.stdout), env.HERDR_PANE_ID, env.HERDR_TAB_ID));
+            schedule(siblings ? HERDR_FAST_MS : HERDR_SLOW_MS);
+        }
+        catch {
+            if (!alive)
+                return;
+            set(undefined);
+            schedule(HERDR_SLOW_MS);
+        }
+        finally {
+            if (inFlight === ac)
+                inFlight = undefined;
+        }
+    };
+    void probe();
+    return {
+        get: () => siblings,
+        onChange: listeners.add,
+        dispose() {
+            if (!alive)
+                return;
+            alive = false;
+            if (timer)
+                clearInterval(timer);
+            timer = undefined;
+            inFlight?.abort();
+            inFlight = undefined;
+            siblings = undefined;
+            listeners.clear();
+        },
+    };
+}