pi-minimal 0.4.0 → 0.6.0

package/dist/reclaim.js

@@ -2,9 +2,6 @@ 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 };
 }

package/dist/rex.js

@@ -0,0 +1,289 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { createListeners } from "./listeners.js";
+export function createRexState() {
+    return { layout: { tabs: new Map(), blocks: new Map() }, status: new Map() };
+}
+const TERMINAL_CREATOR = "com.superlogical.terminal";
+/** Parses `rex window ls -s SESSION --json`. */
+export function parseWindowList(stdout) {
+    const data = JSON.parse(stdout);
+    if (!Array.isArray(data.windows))
+        throw new Error("invalid rex window list");
+    const layout = { tabs: new Map(), blocks: new Map() };
+    for (const window of data.windows) {
+        const windowId = typeof window.window_id === "string" ? window.window_id : undefined;
+        if (!windowId)
+            continue;
+        layout.tabs.set(windowId, typeof window.label === "string" ? window.label : "");
+        for (const layer of window.layers ?? []) {
+            for (const block of layer.blocks ?? []) {
+                if (typeof block.block_id !== "string")
+                    continue;
+                if (block.creator_name !== undefined && block.creator_name !== TERMINAL_CREATOR)
+                    continue;
+                layout.blocks.set(block.block_id, windowId);
+            }
+        }
+    }
+    return layout;
+}
+/** Parses `rex block call -b BLOCK program_status`; returns the root record, if any. */
+export function parseProgramStatus(stdout) {
+    const data = JSON.parse(stdout);
+    if (!Array.isArray(data.records))
+        throw new Error("invalid rex program status");
+    const root = data.records.find((record) => record.id === undefined || record.id === "");
+    return root ? toRecord(root) : undefined;
+}
+function toRecord(raw) {
+    if (typeof raw.state !== "string")
+        return undefined;
+    const record = { state: raw.state };
+    const app = typeof raw.effective_app === "string" ? raw.effective_app : typeof raw.app === "string" ? raw.app : undefined;
+    if (app)
+        record.app = app;
+    if (typeof raw.msg === "string")
+        record.msg = raw.msg;
+    return record;
+}
+/**
+ * Applies one line of `rex events --json` to the state. Returns what changed: `status` (a pane's
+ * record) or `layout` (the caller should re-read the window list). Unknown events are ignored.
+ */
+export function applyRexEvent(state, line) {
+    // Shape: {"type":"session_event","payload":{"session_id":…,"event":{"type":…,"payload":{…}}}}
+    let outer;
+    try {
+        outer = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    if (outer.type !== "session_event")
+        return undefined;
+    const event = outer.payload?.event;
+    const payload = event?.payload ?? {};
+    switch (event?.type) {
+        case "block_event": {
+            const blockId = payload.block_id;
+            if (typeof blockId !== "string")
+                return undefined;
+            const inner = (payload.payload ?? {});
+            if (payload.name === "program_status_changed") {
+                if (inner.id !== "" && inner.id !== undefined)
+                    return undefined;
+                const record = toRecord((inner.record ?? {}));
+                if (!record)
+                    return undefined;
+                state.status.set(blockId, record);
+                return "status";
+            }
+            if (payload.name === "program_status_removed") {
+                const ids = Array.isArray(inner.ids) ? inner.ids : [];
+                if (!ids.includes(""))
+                    return undefined;
+                return state.status.delete(blockId) ? "status" : undefined;
+            }
+            return undefined;
+        }
+        case "block_closed": {
+            const blockId = payload.block_id;
+            if (typeof blockId !== "string")
+                return undefined;
+            state.status.delete(blockId);
+            state.layout.blocks.delete(blockId);
+            return "layout";
+        }
+        case "block_created":
+        case "window_label_changed":
+        case "window_created":
+        case "window_closed":
+        case "session_label_changed":
+            return "layout";
+        default:
+            return undefined;
+    }
+}
+/** A Rex auto-label such as `Window 395a96cb` says nothing about the work; prefer the program. */
+const AUTO_LABEL = /^Window [0-9a-f]+$/i;
+/**
+ * Siblings are named after their tab, like Herdr siblings. A pane in the same tab as this pi
+ * would share our tab's name, so it is named after its program instead.
+ */
+export function listRexSiblings(state, selfBlock) {
+    if (!selfBlock)
+        return undefined;
+    const selfWindow = state.layout.blocks.get(selfBlock);
+    const parts = [];
+    for (const [blockId, record] of state.status) {
+        if (blockId === selfBlock)
+            continue;
+        const windowId = state.layout.blocks.get(blockId);
+        const label = windowId && windowId !== selfWindow ? state.layout.tabs.get(windowId) : undefined;
+        const name = label && !AUTO_LABEL.test(label) ? label : record.app;
+        if (!name)
+            continue;
+        parts.push({ name, status: record.state });
+    }
+    if (parts.length === 0)
+        return undefined;
+    return parts;
+}
+const REX_EXEC_TIMEOUT_MS = 3000;
+const REX_RESTART_MS = 10000;
+const REX_LAYOUT_DEBOUNCE_MS = 150;
+export function createRexSiblings(deps) {
+    const env = deps.env ?? process.env;
+    const spawn = deps.spawn ?? ((command, args) => nodeSpawn(command, args, { stdio: ["ignore", "pipe", "pipe"] }));
+    const session = env.REX_SESSION ?? "";
+    const selfBlock = env.REX_BLOCK;
+    let alive = true;
+    let child;
+    let restartTimer;
+    let layoutTimer;
+    let layoutInFlight = false;
+    let layoutDirty = false;
+    let siblings;
+    const state = createRexState();
+    const listeners = createListeners();
+    const recompute = () => {
+        if (!alive)
+            return;
+        const next = listRexSiblings(state, selfBlock);
+        const changed = JSON.stringify(next) !== JSON.stringify(siblings);
+        siblings = next;
+        if (changed)
+            listeners.notify();
+    };
+    const refreshLayout = async (seedStatus) => {
+        if (!alive)
+            return;
+        if (layoutInFlight) {
+            layoutDirty = true;
+            return;
+        }
+        layoutInFlight = true;
+        try {
+            const run = await deps.pi.exec("rex", ["window", "ls", "-s", session, "--json"], { timeout: REX_EXEC_TIMEOUT_MS });
+            if (!alive)
+                return;
+            if (run.code !== 0 || run.killed)
+                return;
+            const layout = parseWindowList(run.stdout);
+            state.layout = layout;
+            for (const blockId of [...state.status.keys()]) {
+                if (!layout.blocks.has(blockId))
+                    state.status.delete(blockId);
+            }
+            if (seedStatus) {
+                await Promise.all([...layout.blocks.keys()]
+                    .filter((blockId) => blockId !== selfBlock)
+                    .map(async (blockId) => {
+                    try {
+                        const status = await deps.pi.exec("rex", ["block", "call", "-s", session, "-b", blockId, "program_status"], { timeout: REX_EXEC_TIMEOUT_MS });
+                        if (!alive || status.code !== 0 || status.killed)
+                            return;
+                        const record = parseProgramStatus(status.stdout);
+                        if (record)
+                            state.status.set(blockId, record);
+                        else
+                            state.status.delete(blockId);
+                    }
+                    catch {
+                        // A pane that vanished mid-seed shows up via events later.
+                    }
+                }));
+            }
+            recompute();
+        }
+        catch {
+            // Keep the last known layout; the next layout event retries.
+        }
+        finally {
+            layoutInFlight = false;
+            if (layoutDirty && alive) {
+                layoutDirty = false;
+                void refreshLayout(false);
+            }
+        }
+    };
+    const scheduleLayoutRefresh = () => {
+        if (!alive || layoutTimer)
+            return;
+        layoutTimer = setTimeout(() => {
+            layoutTimer = undefined;
+            void refreshLayout(false);
+        }, REX_LAYOUT_DEBOUNCE_MS);
+    };
+    const start = () => {
+        if (!alive)
+            return;
+        restartTimer = undefined;
+        let proc;
+        try {
+            proc = spawn("rex", ["events", "-s", session, "--json"]);
+        }
+        catch {
+            scheduleRestart();
+            return;
+        }
+        child = proc;
+        if (proc.stdout) {
+            const lines = createInterface({ input: proc.stdout });
+            lines.on("line", (line) => {
+                if (!alive || child !== proc)
+                    return;
+                const effect = applyRexEvent(state, line);
+                if (effect === "status")
+                    recompute();
+                else if (effect === "layout") {
+                    recompute();
+                    scheduleLayoutRefresh();
+                }
+            });
+        }
+        proc.on("error", () => { if (child === proc)
+            onExit(); });
+        proc.on("exit", () => { if (child === proc)
+            onExit(); });
+        void refreshLayout(true);
+    };
+    const onExit = () => {
+        child = undefined;
+        if (!alive)
+            return;
+        state.status.clear();
+        recompute();
+        scheduleRestart();
+    };
+    const scheduleRestart = () => {
+        if (!alive || restartTimer)
+            return;
+        restartTimer = setTimeout(start, REX_RESTART_MS);
+    };
+    start();
+    return {
+        get: () => siblings,
+        onChange: listeners.add,
+        dispose() {
+            if (!alive)
+                return;
+            alive = false;
+            if (restartTimer)
+                clearTimeout(restartTimer);
+            if (layoutTimer)
+                clearTimeout(layoutTimer);
+            restartTimer = undefined;
+            layoutTimer = undefined;
+            const proc = child;
+            child = undefined;
+            try {
+                proc?.kill();
+            }
+            catch { /* already gone */ }
+            siblings = undefined;
+            listeners.clear();
+        },
+    };
+}

package/dist/session.js

@@ -0,0 +1,168 @@
+import { getAgentDir, SettingsManager } from "@earendil-works/pi-coding-agent";
+import { setChromeMargin } from "./chrome.js";
+import { loadPiMinimalConfig } from "./config.js";
+import { installCwd } from "./cwd.js";
+import { installFooter } from "./footer.js";
+import { bindFooterContributionEvents } from "./footer-contribution-events.js";
+import { createFooterContributions } from "./footer-contributions.js";
+import { createGitState } from "./git-state.js";
+import { installHeader } from "./header.js";
+import { createBackgroundTracker } from "./background.js";
+import { backgroundSegment } from "./background-overlay.js";
+import { createPrSource, findPrUrls, prSegment } from "./prs.js";
+import { applyReclaim, reclaimPolicy } from "./reclaim.js";
+import { createSiblingSource } from "./siblings.js";
+import { setSessionCwd } from "./tool-rows.js";
+import { setEditDiffMode } from "./tools.js";
+import { hideGauntletWidgets } from "./tracker.js";
+/** Custom session entry remembering a PR this session created, so a resumed session shows it. */
+export const PR_ENTRY_TYPE = "pi-minimal.pr";
+function readSessionPrs(ctx) {
+    const urls = [];
+    try {
+        for (const entry of ctx.sessionManager.getBranch()) {
+            if (entry.type !== "custom" || entry.customType !== PR_ENTRY_TYPE)
+                continue;
+            const url = entry.data?.url;
+            if (typeof url === "string")
+                urls.push(url);
+        }
+    }
+    catch {
+        // No branch available (tests, odd hosts): start empty.
+    }
+    return urls;
+}
+/**
+ * Everything pi-minimal owns for one session: config, cwd, the contribution registry, the git
+ * poller, the sibling source (Herdr or Rex), and the header/footer/status-line chrome. Disposal stops every timer and makes
+ * late async results inert, so two sessions in one process never share or overwrite each other's
+ * state. Non-TUI sessions get a session too, but it only binds the contribution protocol (which
+ * replies `not-tui`) and installs no chrome.
+ */
+export function createSession(pi, ctx, deps) {
+    const id = ctx.sessionManager.getSessionId();
+    let alive = true;
+    const contributions = createFooterContributions();
+    const stopContributionEvents = bindFooterContributionEvents(pi.events, contributions, id, ctx.mode);
+    if (ctx.mode !== "tui") {
+        return { id, pin() { }, refreshGit() { }, notePrUrls() { }, dispose() { if (!alive)
+                return; alive = false; stopContributionEvents(); } };
+    }
+    const config = loadPiMinimalConfig({ agentDir: getAgentDir(), cwd: ctx.cwd, projectTrusted: ctx.isProjectTrusted() });
+    setSessionCwd(ctx.cwd);
+    setEditDiffMode(config.editDiff);
+    try {
+        const settings = SettingsManager.create(ctx.cwd, undefined, { projectTrusted: ctx.isProjectTrusted() });
+        setChromeMargin(settings.getOutputPad());
+    }
+    catch {
+        // Keep the current margin when settings are unavailable.
+    }
+    const gitState = createGitState(pi, () => ctx.cwd);
+    let stopFooter = () => { };
+    let siblings;
+    const background = createBackgroundTracker({ pi });
+    const prs = createPrSource({ pi, cwd: () => ctx.cwd, sessionPrs: readSessionPrs(ctx) });
+    const settleTimers = [];
+    const contextPct = () => {
+        const usage = ctx.getContextUsage?.();
+        const window = usage?.contextWindow || ctx.model?.contextWindow;
+        if (typeof usage?.tokens !== "number" || !window)
+            return undefined;
+        return Math.max(0, Math.min(100, Math.round((usage.tokens / window) * 100)));
+    };
+    const installChromeFooter = () => {
+        stopFooter();
+        stopFooter = installFooter(ctx, {
+            busy: deps.busy,
+            editorText: () => (typeof ctx.ui.getEditorText === "function" ? ctx.ui.getEditorText() : ""),
+            contextPct,
+            prs: (theme) => {
+                const snap = prs.get();
+                return prSegment(snap.prs, theme, 4, snap.repo ? `${snap.repo.host}/${snap.repo.nameWithOwner}` : undefined);
+            },
+            onPrsChange: prs.onChange,
+            background: () => backgroundSegment(background.get()),
+            onBackgroundChange: background.onChange,
+        }, contributions);
+    };
+    const installStatusLine = () => {
+        installCwd(ctx, {
+            gitState: gitState.get,
+            siblings: () => siblings?.get(),
+            onChange(listener) {
+                const offGit = gitState.onChange(listener);
+                const offSiblings = siblings?.onChange(listener) ?? (() => { });
+                return () => { offGit(); offSiblings(); };
+            },
+        });
+    };
+    const pin = (reason) => {
+        if (!alive)
+            return;
+        applyReclaim(reason, ctx.ui, {
+            widgets: () => { if (config.hideGauntletWidgets)
+                hideGauntletWidgets(ctx); },
+            chrome: () => { installHeader(ctx); installChromeFooter(); },
+        });
+        if (!reclaimPolicy(reason).reinstallChrome)
+            return;
+        ctx.ui.setWidget("tw-cwd", undefined);
+        installStatusLine();
+    };
+    // The source is chosen from the environment (HERDR_ENV, else REX_SESSION/REX_BLOCK); start it
+    // before the status line so its onChange subscription is live.
+    siblings = createSiblingSource({ pi, spawn: deps.spawn });
+    // Install once, then re-assert shortly after: other extensions' session_start handlers may draw after ours.
+    installHeader(ctx);
+    installChromeFooter();
+    installStatusLine();
+    void gitState.refresh(true);
+    pin("session_start");
+    ctx.ui.setHiddenThinkingLabel("◆ Thought");
+    ctx.ui.setWorkingIndicator();
+    for (const delay of [0, 50])
+        settleTimers.push(setTimeout(() => pin("session_settle"), delay));
+    return {
+        id,
+        background,
+        backgroundShortcut: config.backgroundShortcut,
+        prs,
+        notePrUrls(text) {
+            if (!alive)
+                return;
+            const known = new Set(prs.sessionPrs());
+            for (const url of findPrUrls(text)) {
+                if (known.has(url))
+                    continue;
+                prs.addSessionPr(url);
+                try {
+                    pi.appendEntry?.(PR_ENTRY_TYPE, { url });
+                }
+                catch {
+                    // A session that cannot accept entries just forgets the PR on restart.
+                }
+            }
+        },
+        pin,
+        refreshGit(force) { if (alive) {
+            void gitState.refresh(force);
+            void prs.refresh();
+        } },
+        dispose() {
+            if (!alive)
+                return;
+            alive = false;
+            for (const timer of settleTimers.splice(0))
+                clearTimeout(timer);
+            background.dispose();
+            prs.dispose();
+            siblings?.dispose();
+            siblings = undefined;
+            gitState.dispose();
+            stopFooter();
+            stopContributionEvents();
+        },
+    };
+}

package/dist/siblings.js

@@ -0,0 +1,14 @@
+import { createHerdrSiblings } from "./herdr.js";
+import { createRexSiblings } from "./rex.js";
+/**
+ * Picks the host the session runs in. Herdr wins when both are present (Rex inside a Herdr pane):
+ * Herdr knows every agent it launched, Rex only the programs that report status.
+ */
+export function createSiblingSource(deps) {
+    const env = deps.env ?? process.env;
+    if (env.HERDR_ENV === "1")
+        return createHerdrSiblings(deps.pi, env);
+    if (env.REX_SESSION && env.REX_BLOCK)
+        return createRexSiblings({ pi: deps.pi, env, spawn: deps.spawn });
+    return undefined;
+}