pi-minimal 0.1.0

package/dist/tools.js

@@ -0,0 +1,103 @@
+import { createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition, SettingsManager, } from "@earendil-works/pi-coding-agent";
+import { Container, Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { activityBullet, rowIsRunning } from "./activity.js";
+import { createLiveWatch } from "./live-watch.js";
+import { nextGroupedRow, toolItem } from "./tool-rows.js";
+const live = createLiveWatch(400);
+export function stopLiveWatch() {
+    live.stop();
+}
+function liveId(context, item) {
+    return context.toolCallId || item;
+}
+function contentText(result) {
+    if (!result?.content)
+        return "";
+    return result.content
+        .filter((part) => part.type === "text" && typeof part.text === "string")
+        .map((part) => part.text)
+        .join("\n");
+}
+function collapsedResult() {
+    return new Container();
+}
+function expandedContent(result, options) {
+    if (!options.expanded)
+        return collapsedResult();
+    const text = contentText(result);
+    return text ? new Text(text, 0, 0) : collapsedResult();
+}
+function activityBlock(kind, args, theme, context) {
+    const item = toolItem(kind, args);
+    const id = liveId(context, item);
+    const row = nextGroupedRow(kind, item, id);
+    const running = rowIsRunning(context);
+    context.state.running = running;
+    if (running)
+        live.watch(id, context.invalidate);
+    else
+        live.unwatch(id);
+    const color = context.isError ? "error" : running ? "warning" : "dim";
+    return {
+        render(width) {
+            const pad = 1;
+            const inner = Math.max(0, width - pad);
+            const lines = [];
+            if (row.header) {
+                const blink = Boolean(context.state.running) && live.has(id);
+                const bullet = activityBullet(blink, live.frame);
+                lines.push(" ".repeat(pad) + theme.fg(color, truncateToWidth(`${bullet} ${row.header}`, inner)));
+            }
+            lines.push(" ".repeat(pad) + "  " + theme.fg(color, truncateToWidth(row.item, Math.max(0, inner - 2))));
+            return lines;
+        },
+        invalidate() { },
+    };
+}
+function wrapOne(pi, kind, factory) {
+    try {
+        const tool = factory();
+        pi.registerTool({
+            ...tool,
+            renderShell: "self",
+            renderCall(args, theme, context) {
+                return activityBlock(kind, args, theme, context);
+            },
+            renderResult(result, options, _theme, context) {
+                const renderContext = context;
+                if (!renderContext.isPartial) {
+                    renderContext.state.done = true;
+                    renderContext.state.running = false;
+                    live.unwatch(liveId(renderContext, toolItem(kind, renderContext.args)));
+                }
+                return expandedContent(result, options);
+            },
+        });
+    }
+    catch {
+        // A missing built-in tool leaves the rest of the compact renderers available.
+    }
+}
+export function wrapBuiltinTools(pi, ctx) {
+    let commandPrefix;
+    let shellPath;
+    let autoResizeImages;
+    try {
+        const settings = SettingsManager.create(ctx.cwd, undefined, {
+            projectTrusted: ctx.isProjectTrusted(),
+        });
+        commandPrefix = settings.getShellCommandPrefix();
+        shellPath = settings.getShellPath();
+        autoResizeImages = settings.getImageAutoResize();
+    }
+    catch {
+        // Tool wrapping still works when optional shell or image settings are unavailable.
+    }
+    wrapOne(pi, "bash", () => createBashToolDefinition(ctx.cwd, { commandPrefix, shellPath }));
+    wrapOne(pi, "read", () => createReadToolDefinition(ctx.cwd, { autoResizeImages }));
+    wrapOne(pi, "edit", () => createEditToolDefinition(ctx.cwd));
+    wrapOne(pi, "write", () => createWriteToolDefinition(ctx.cwd));
+    wrapOne(pi, "grep", () => createGrepToolDefinition(ctx.cwd));
+    wrapOne(pi, "find", () => createFindToolDefinition(ctx.cwd));
+    wrapOne(pi, "ls", () => createLsToolDefinition(ctx.cwd));
+}

package/dist/tracker.js

@@ -0,0 +1,63 @@
+const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"];
+function readSnapshot(ctx) {
+    let phases;
+    let tasks;
+    for (const entry of ctx.sessionManager.getBranch()) {
+        if (entry.type !== "message")
+            continue;
+        const msg = entry.message;
+        if (msg.role !== "toolResult" || !msg.details || msg.details.error)
+            continue;
+        if (msg.toolName === "phase_tracker" && msg.details.phases) {
+            phases = msg.details.phases;
+        }
+        if (msg.toolName === "plan_tracker" && msg.details.tasks) {
+            tasks = msg.details.tasks;
+        }
+    }
+    return { phases, tasks };
+}
+function phaseActive(phases) {
+    return PHASES.some((p) => phases[p]?.status && phases[p].status !== "pending");
+}
+export function formatTrackerLines(ctx, theme) {
+    const { phases, tasks } = readSnapshot(ctx);
+    const lines = [];
+    if (phases && phaseActive(phases)) {
+        const parts = PHASES.map((p) => {
+            const st = phases[p]?.status || "pending";
+            const icon = st === "complete"
+                ? theme.fg("success", "✓")
+                : st === "in_progress"
+                    ? theme.fg("warning", "→")
+                    : st === "skipped"
+                        ? theme.fg("dim", "⊘")
+                        : theme.fg("dim", "○");
+            const label = st === "skipped" ? theme.fg("dim", p) : p;
+            return `${icon} ${label}`;
+        });
+        lines.push(`${theme.fg("muted", "Phases")} ${parts.join(theme.fg("dim", " → "))}`);
+    }
+    if (tasks && tasks.length > 0) {
+        const done = tasks.filter((t) => t.status === "complete").length;
+        const icons = tasks
+            .map((t) => {
+            if (t.status === "complete")
+                return theme.fg("success", "✓");
+            if (t.status === "in_progress")
+                return theme.fg("warning", "→");
+            if (t.status === "failed")
+                return theme.fg("error", "✗");
+            return theme.fg("dim", "○");
+        })
+            .join("");
+        const current = tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending");
+        const name = current ? theme.fg("text", ` ${current.name}`) : "";
+        lines.push(`${theme.fg("muted", "Tasks")} ${icons} ${theme.fg("dim", `(${done}/${tasks.length})`)}${name}`);
+    }
+    return lines;
+}
+export function hideGauntletWidgets(ctx) {
+    ctx.ui.setWidget("phase_tracker", undefined);
+    ctx.ui.setWidget("plan_tracker", undefined);
+}

package/dist/working-status.js

@@ -0,0 +1,191 @@
+const DETAIL_MAX = 120;
+export function formatElapsed(ms) {
+    const total = Math.max(0, Math.floor(ms / 1000));
+    const hours = Math.floor(total / 3600);
+    const minutes = Math.floor((total % 3600) / 60);
+    const seconds = total % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+export function clipDetail(text, max = DETAIL_MAX) {
+    const one = text.replace(/\s+/g, " ").trim();
+    if (one.length <= max)
+        return one;
+    if (max <= 1)
+        return "…";
+    return `${one.slice(0, max - 1).trimEnd()}…`;
+}
+export function lastThoughtLine(message) {
+    if (!Array.isArray(message?.content))
+        return undefined;
+    let thinking = "";
+    for (const part of message.content) {
+        if (part?.type === "thinking" && typeof part.thinking === "string") {
+            thinking = part.thinking;
+        }
+    }
+    const lines = thinking
+        .split("\n")
+        .map((line) => line.replace(/^[#>*\-\d.\s]+/, "").trim())
+        .filter((line) => line.length > 2);
+    if (lines.length === 0)
+        return undefined;
+    return clipDetail(lines.slice(-2).join(" · "));
+}
+export function summarizeTool(name, args) {
+    const path = (typeof args?.path === "string" && args.path) ||
+        (typeof args?.file_path === "string" && args.file_path) ||
+        (typeof args?.target_directory === "string" && args.target_directory) ||
+        "";
+    const pattern = typeof args?.pattern === "string" ? args.pattern : "";
+    const command = typeof args?.command === "string" ? args.command.split("\n")[0]?.trim() ?? "" : "";
+    const base = path.split("/").filter(Boolean).slice(-2).join("/") || path;
+    switch (name) {
+        case "bash":
+            return command ? `Running ${clipDetail(command, 56)}` : "Running";
+        case "read":
+            return base ? `Reading ${base}` : "Reading";
+        case "edit":
+            return base ? `Editing ${base}` : "Editing";
+        case "write":
+            return base ? `Writing ${base}` : "Writing";
+        case "grep":
+            return pattern ? `Grep ${clipDetail(pattern, 40)}` : "Grep";
+        case "find":
+            return pattern ? `Finding ${clipDetail(pattern, 40)}` : "Finding";
+        case "ls":
+            return base ? `Listing ${base}` : "Listing";
+        default:
+            return name || "Working";
+    }
+}
+export function formatWorkingMessage(snap) {
+    const elapsed = formatElapsed(snap.now - snap.startedAt);
+    if (snap.phase === "tool" && snap.tool) {
+        const extra = snap.toolCount && snap.toolCount > 1 ? ` · ${snap.toolCount} tools` : "";
+        return `${snap.tool}${extra} · ${elapsed}`;
+    }
+    if (snap.phase === "writing")
+        return `Writing · ${elapsed}`;
+    if (snap.thought)
+        return `Thinking · ${snap.thought} · ${elapsed}`;
+    return `Thinking · ${elapsed}`;
+}
+export function installWorkingStatus(pi) {
+    let ctx;
+    let startedAt = 0;
+    let phase = "idle";
+    let thought;
+    let lastMessage = "";
+    let timer;
+    const tools = new Map();
+    const stop = () => {
+        if (timer)
+            clearInterval(timer);
+        timer = undefined;
+        startedAt = 0;
+        phase = "idle";
+        thought = undefined;
+        lastMessage = "";
+        tools.clear();
+        if (ctx?.mode === "tui")
+            ctx.ui.setWorkingMessage();
+    };
+    const paint = (now = Date.now()) => {
+        if (!ctx || ctx.mode !== "tui" || phase === "idle")
+            return;
+        const next = formatWorkingMessage({
+            phase,
+            startedAt,
+            now,
+            thought,
+            tool: [...tools.values()].at(-1),
+            toolCount: tools.size,
+        });
+        if (next === lastMessage)
+            return;
+        lastMessage = next;
+        ctx.ui.setWorkingMessage(next);
+    };
+    const startClock = () => {
+        if (!startedAt)
+            startedAt = Date.now();
+        if (!timer)
+            timer = setInterval(() => paint(), 1000);
+    };
+    pi.on("session_start", (_event, next) => {
+        if (next.mode !== "tui")
+            return;
+        ctx = next;
+    });
+    pi.on("agent_start", () => {
+        if (!ctx || ctx.mode !== "tui")
+            return;
+        if (phase === "idle") {
+            tools.clear();
+            thought = undefined;
+            lastMessage = "";
+            startedAt = Date.now();
+        }
+        if (tools.size === 0)
+            phase = "thinking";
+        startClock();
+        paint();
+    });
+    pi.on("turn_start", () => {
+        if (phase === "idle")
+            return;
+        if (tools.size === 0)
+            phase = "thinking";
+        startClock();
+        paint();
+    });
+    pi.on("message_update", (event) => {
+        if (phase === "idle")
+            return;
+        const ev = event;
+        if (ev.message?.role && ev.message.role !== "assistant")
+            return;
+        const kind = ev.assistantMessageEvent?.type;
+        const nextThought = lastThoughtLine(ev.message);
+        if (nextThought)
+            thought = nextThought;
+        if (kind === "text_start" || kind === "text_delta" || kind === "text_end") {
+            if (tools.size === 0)
+                phase = "writing";
+        }
+        else if (tools.size === 0) {
+            phase = "thinking";
+        }
+        paint();
+    });
+    pi.on("tool_execution_start", (event) => {
+        if (phase === "idle")
+            return;
+        const ev = event;
+        const id = ev.toolCallId || `${ev.toolName}-${tools.size}`;
+        tools.set(id, summarizeTool(ev.toolName || "tool", ev.args));
+        phase = "tool";
+        paint();
+    });
+    pi.on("tool_execution_end", (event) => {
+        if (phase === "idle")
+            return;
+        const ev = event;
+        if (ev.toolCallId)
+            tools.delete(ev.toolCallId);
+        phase = tools.size > 0 ? "tool" : "thinking";
+        paint();
+    });
+    pi.on("agent_settled", () => {
+        stop();
+    });
+    pi.on("session_shutdown", () => {
+        ctx = undefined;
+        stop();
+    });
+    return stop;
+}