agent-from-zero 0.31.0 → 0.32.1

package/dist/ink/commands.js

@@ -0,0 +1,103 @@
+import chalk from "chalk";
+import path from "node:path";
+import { CONFIG } from "../config.js";
+import { statsReport } from "../telemetry.js";
+import { readMemoryTyped, MEMORY_PATH } from "../memory.js";
+import { getTodos, renderTodos } from "../todos.js";
+import { listBackground } from "../background.js";
+import { listTeam } from "../team.js";
+import { boardSummary } from "../board.js";
+import { undoLast, sessionChanges } from "../undo.js";
+import { renderDiff } from "../diff.js";
+// The non-interactive slash commands: each produces a block of text to commit as
+// a note. Lifted from agent.ts's handleCommand, with console.log → a returned
+// string so the Ink REPL can render them inside its tree. The stateful commands
+// (/clear, /compact, /plan, /model, /resume, /skill) stay in the App — they
+// mutate the conversation or pop an interactive menu.
+// The in-session command reference shown by /help.
+export const SESSION_HELP = `commands:
+  /help      this text
+  /clear     wipe the conversation (and the file read-state) — fresh start
+  /compact   compact the history into a summary right now (happens automatically near the limit)
+  /model     switch model for THIS session: "/model" to pick from a list, "/model <name>" to set; "/model save <name>" to make it your default
+  /stats     event counts for this session (local telemetry — nothing leaves this machine)
+  /memory    show the durable facts the agent remembers about this project
+  /cost      tokens, cache hit rate and estimated spend this session (local)
+  /plan      toggle plan mode — research-only; the agent presents a plan you approve before any change
+  /todos     show the agent's current task plan (it maintains one with todo_write on multi-step work)
+  /bg        list background tasks this session (run_bash_background) and their status
+  /team      list the agent team (spawn_teammate): each teammate's role, status, and pending inbox
+  /tasks     show the shared task board (create_task/claim_task): each task's status, owner, and dependencies
+  /undo      revert the most recent file write (write_file / edit_file) this session
+  /diff      show every file changed this session, as a diff from where it started
+  /resume    list recent sessions in this project and continue one of them
+  /skills    list the reusable skills available in this project
+  /skill <name>  run a skill yourself (works even for user-only skills)
+  exit       leave (Ctrl+C does the same)
+
+keys (at the prompt):
+  Ctrl+R     reveal the model's thinking for the last answer (collapsed behind a spinner by default)
+  Ctrl+T     reveal the folded tool-call trace for the last answer`;
+// Run a non-interactive command. Returns the note text to display, or null if
+// `line` isn't one of these (the App handles the rest).
+export function runInfoCommand(line, ctx) {
+    switch (line) {
+        case "/help":
+            return chalk.dim(SESSION_HELP);
+        case "/cost":
+            return chalk.dim(ctx.costMeter.report()); // tokens, cache hit rate, estimated spend (local)
+        case "/stats":
+            return chalk.dim(statsReport()); // local counters, busiest first
+        case "/memory": {
+            const entries = readMemoryTyped();
+            return chalk.dim(entries.length
+                ? `long-term memory (${MEMORY_PATH}):\n${entries.map((e) => `  [${e.type}] ${e.fact}`).join("\n")}`
+                : `(no long-term memory yet — the model saves facts with the remember tool${CONFIG.memory.autoExtract ? "" : "; turn on settings.memory.autoExtract to capture them automatically"})`);
+        }
+        case "/todos": {
+            const todos = getTodos();
+            return todos.length ? renderTodos(todos) : chalk.dim("(no plan yet — the agent writes one with todo_write on multi-step tasks)");
+        }
+        case "/bg": {
+            const bg = listBackground();
+            if (!bg.length)
+                return chalk.dim("(no background tasks — the agent starts them with run_bash_background for slow commands)");
+            const icon = { running: chalk.yellow("●"), completed: chalk.green("✓"), failed: chalk.red("✗"), killed: chalk.dim("∅") };
+            return chalk.dim("background tasks this session:\n") + bg.map((t) => chalk.dim(`  ${icon[t.status]} ${t.id} [${t.status}, ${t.elapsed}s] — ${t.command.slice(0, 70)}`)).join("\n");
+        }
+        case "/team": {
+            const team = listTeam();
+            if (!team.length)
+                return chalk.dim("(no team — the agent forms one with spawn_teammate for large parallel tasks)");
+            const icon = { active: chalk.yellow("●"), idle: chalk.cyan("◐"), done: chalk.green("✓"), failed: chalk.red("✗") };
+            return (chalk.dim("agent team this session:\n") +
+                team.map((t) => chalk.dim(`  ${icon[t.status] ?? "?"} ${t.name} [${t.status}, ${t.elapsed}s] — ${t.role.slice(0, 60)}${t.pending ? chalk.yellow(` · ${t.pending} unread`) : ""}`)).join("\n"));
+        }
+        case "/tasks": {
+            const summary = boardSummary();
+            return summary === "(the task board is empty)" ? chalk.dim("(no tasks — the lead adds them with create_task; teammates claim them autonomously)") : chalk.dim(`task board:\n${summary}`);
+        }
+        case "/skills": {
+            if (!ctx.skills.length)
+                return chalk.dim("(no skills — add one at .mini-agent/skills/<name>/SKILL.md or ~/.config/mini-agent/skills/)");
+            return (chalk.dim("skills in this project:\n") +
+                ctx.skills.map((s) => chalk.dim(`  ${s.name} [${s.disableModelInvocation ? chalk.yellow("user-only") : chalk.green("model+user")}${chalk.dim("]")} — ${(s.whenToUse || s.description).slice(0, 70)}`)).join("\n"));
+        }
+        case "/undo": {
+            const undone = undoLast();
+            if (!undone)
+                return chalk.dim("(nothing to undo — no file writes recorded this session)");
+            return chalk.dim(`↩ ${undone.summary}`) + "\n" + renderDiff(undone.after ?? "", undone.before ?? "");
+        }
+        case "/diff": {
+            const changes = sessionChanges();
+            if (!changes.length)
+                return chalk.dim("(no file changes this session)");
+            const verb = { created: chalk.green("created"), modified: chalk.yellow("modified"), deleted: chalk.red("deleted") };
+            const head = chalk.dim(`${changes.length} file${changes.length === 1 ? "" : "s"} changed this session:`);
+            return head + "\n" + changes.map((c) => `\n${verb[c.status]} ${path.relative(process.cwd(), c.path) || c.path}\n${renderDiff(c.baseline, c.current)}`).join("");
+        }
+        default:
+            return null; // not an info command — the App handles it (or it's a normal task line)
+    }
+}

package/dist/ink/launch.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { buildInkSession } from "./setup.js"; // the front-end-agnostic session bootstrap
+import { makeRunTurn } from "./chat.js"; // drives one turn through the real loop
+import { App } from "./app.js"; // the Ink REPL
+// Launch the Ink REPL and resolve when it exits. buildInkSession does the same
+// wiring agent.ts does (MCP, skills, judge, memory, cost, hooks, telemetry,
+// optional resume); App renders it and runs the loop. Exported so BOTH the
+// `npm run ink` entry (main.tsx) and agent.ts (the default `mini-agent` entry,
+// once it hands interactive sessions to Ink) can start it.
+export async function launchInk(opts = {}) {
+    const session = await buildInkSession({ resume: opts.resume });
+    const { waitUntilExit } = render(_jsx(App, { session: session, runTurn: makeRunTurn(session.client, session.messages) }));
+    await waitUntilExit(); // keep the process alive until the user quits
+}

package/dist/ink/main.js

@@ -0,0 +1,4 @@
+import { launchInk } from "./launch.js"; // the reusable launcher (shared with agent.ts)
+// Direct entry for the Ink REPL: npm run ink. agent.ts launches the same thing
+// for a normal `mini-agent` interactive session.
+await launchInk({ resume: process.argv.includes("-r") || process.argv.includes("--resume") });

package/dist/ink/setup.js

@@ -0,0 +1,104 @@
+import OpenAI from "openai";
+import path from "node:path";
+import { createRequire } from "node:module";
+import { CONFIG, requireApiKey } from "../config.js";
+import { buildSystemMessage } from "../prompt.js";
+import { estimateHistoryTokens } from "../context.js";
+import { initCostMeter, DEFAULT_PRICING } from "../cost.js";
+import { gitBranch } from "../tui.js";
+import { newSessionId, latestSession } from "../session.js";
+import { initTelemetry, emit } from "../telemetry.js";
+import { runHooks } from "../hooks.js";
+import { connectMcpServers } from "../mcp.js";
+import { Judge } from "../judge.js";
+import { registerExternalTool } from "../tools.js";
+import { rememberTool, readMemory } from "../memory.js";
+import { loadSkills, buildSkillTool } from "../skills.js";
+import { killAllBackground } from "../background.js";
+import { killAllSubAgents } from "../loop.js";
+import { banner } from "../ui.js";
+// The Ink REPL's session bootstrap — the same wiring agent.ts (the readline REPL)
+// does before the prompt loop, but front-end-agnostic: it touches none of
+// readline/editLine, just the shared modules (MCP, skills, judge, memory, cost,
+// hooks, telemetry, session). It returns everything the Ink App needs to run a
+// real session, so main.tsx stays a thin render() call. (agent.ts is left
+// untouched so `npm start` keeps working until 2d flips the default.)
+const pkg = createRequire(import.meta.url)("../../package.json");
+// Build the session. `resume` mirrors `-r/--resume`: fold the most recent
+// conversation in this directory into the fresh constitution.
+export async function buildInkSession(opts = {}) {
+    requireApiKey();
+    const client = new OpenAI({ baseURL: CONFIG.baseURL, apiKey: CONFIG.apiKey, maxRetries: 0 });
+    const systemMessage = buildSystemMessage(); // stable prefix = cache hits every request
+    const messages = [{ role: "system", content: systemMessage }];
+    const notices = [];
+    let sessionId = newSessionId();
+    const startedAt = Date.now();
+    if (opts.resume) {
+        const prev = latestSession();
+        if (prev) {
+            messages.push(...prev.messages);
+            sessionId = prev.id; // keep appending to the same file
+            notices.push(`(resumed session ${prev.id} — ${prev.messages.length} messages; files must be re-read before editing)`);
+        }
+        else {
+            notices.push("(no previous session here — starting fresh)");
+        }
+    }
+    initTelemetry(sessionId);
+    emit("agent_session_start", { mode: "repl" });
+    // MCP servers — must finish before the first model call so their tools appear
+    // in the manual. A server that fails to start is skipped, never fatal.
+    const disconnectMcp = await connectMcpServers();
+    process.on("exit", disconnectMcp);
+    process.on("exit", killAllBackground); // SIGKILL any background job so it never outlives the agent
+    process.on("exit", killAllSubAgents); // mark any still-running sub-agents as killed
+    const judge = CONFIG.judge.enabled ? new Judge(client, CONFIG.judge.model || CONFIG.model) : undefined;
+    if (judge)
+        notices.push(`(permission judge on — model ${CONFIG.judge.model || CONFIG.model})`);
+    // The remember tool flows through the same permission gate as any tool.
+    registerExternalTool(rememberTool);
+    const memCount = readMemory().length;
+    if (memCount)
+        notices.push(`(long-term memory: ${memCount} facts loaded)`);
+    // Skills: model-invocable ones get the single `skill` tool; user-only ones are
+    // reachable via /skill <name>.
+    const skills = loadSkills();
+    if (skills.some((s) => !s.disableModelInvocation))
+        registerExternalTool(buildSkillTool(skills));
+    if (skills.length)
+        notices.push(`(skills: ${skills.length} loaded — ${skills.map((s) => s.name).join(", ")})`);
+    const costMeter = initCostMeter({
+        inputPerM: CONFIG.pricing.inputPerM ?? DEFAULT_PRICING.inputPerM,
+        cachedInputPerM: CONFIG.pricing.cachedInputPerM ?? DEFAULT_PRICING.cachedInputPerM,
+        outputPerM: CONFIG.pricing.outputPerM ?? DEFAULT_PRICING.outputPerM,
+    });
+    // SessionStart hooks run once; their stdout becomes context on the first turn.
+    const sessionStart = await runHooks("SessionStart", {});
+    if (sessionStart.stdout)
+        messages.push({ role: "user", content: `[SessionStart hook]\n${sessionStart.stdout}` });
+    const dir = path.basename(process.cwd());
+    const branch = gitBranch();
+    const getStatus = () => ({
+        ctxPct: Math.min(100, Math.round((estimateHistoryTokens(messages) / CONFIG.contextWindow) * 100)),
+        cost: costMeter.cost(),
+        elapsedMs: Date.now() - startedAt,
+    });
+    return {
+        client,
+        messages,
+        systemMessage,
+        initialSessionId: sessionId,
+        startedAt,
+        costMeter,
+        skills,
+        judge,
+        model: CONFIG.model,
+        dir,
+        branch,
+        bannerText: banner(pkg.version, CONFIG.model, new URL(CONFIG.baseURL).host),
+        notices,
+        getStatus,
+        disconnectMcp,
+    };
+}

package/dist/ink/sink.js

@@ -0,0 +1,50 @@
+// Build a LoopOutput backed by Ink state. Pure glue: every method maps a loop
+// event to a state change.
+export function makeInkSink(api) {
+    return {
+        // A spinner becomes the single "status" line below the conversation. A fresh
+        // handle per model call (the loop makes one per round); `active` mirrors
+        // ora's isSpinning so the loop's `spinner?.spinning` checks behave the same.
+        spinner(text) {
+            api.setStatus(text);
+            let active = true;
+            return {
+                set: (t) => {
+                    if (active)
+                        api.setStatus(t);
+                },
+                stop: () => {
+                    if (active) {
+                        active = false;
+                        api.setStatus(null);
+                    }
+                },
+                get spinning() {
+                    return active;
+                },
+            };
+        },
+        // The "💭 thought for Ns" indicator is just a committed line.
+        reasoning: (line) => api.pushItem({ kind: "note", text: line }),
+        // The streamed answer accumulates in the dynamic region as raw text (live,
+        // "it's typing"), then commits as ONE markdown-rendered item when it ends —
+        // partial markdown mid-stream renders badly, so we format only once it's whole.
+        answer() {
+            let buf = "";
+            api.setLive("");
+            return {
+                push: (tok) => {
+                    buf += tok;
+                    api.setLive(buf);
+                },
+                end: () => {
+                    api.setLive(null); // clear the live preview first, then commit (no flicker/duplicate)
+                    if (buf.trim())
+                        api.pushItem({ kind: "answer", text: buf });
+                },
+            };
+        },
+        // Generic narration — already chalk-formatted by the loop; just commit it.
+        note: (line) => api.pushItem({ kind: "note", text: line }),
+    };
+}