@vigent/cli 0.2.3 → 0.3.1

package/dist/session.js

@@ -1,3 +1,14 @@
+/**
+ * Session layer: one Session per agent.
+ *
+ * - PiSession runs a real pi coding agent in-process, with its read / write /
+ *   edit / bash tools rooted in the agent's own git worktree.
+ * - DemoSession replays a scripted transcript so the UI can be explored
+ *   without API keys.
+ */
+import { expandPrompt } from "./attach.js";
+import { loadPiAi, loadPiSdk } from "./pi-sdk.js";
+import { extensionUi, piResources } from "./pi-ui.js";
 import { flattenTree } from "./tree.js";
 import { diffStat } from "./worktree.js";
 export const STATE_GLYPH = {
@@ -20,6 +31,8 @@ export class Session {
     state = "idle";
     items = [];
     tokens = 0;
+    /** money spent, in US dollars, as the engine reports it; undefined = the engine doesn't say (Codex) */
+    cost;
     version = 0; // bumped on every change, used for render caching
     listeners = new Set();
     statTimer;
@@ -244,7 +257,7 @@ export class PiSession extends Session {
         this.ready = this.init();
     }
     async init() {
-        const sdk = await import("@mariozechner/pi-coding-agent");
+        const sdk = await loadPiSdk();
         const sessionManager = this.opts.sessionDir
             ? sdk.SessionManager.continueRecent(this.cwd, this.opts.sessionDir)
             : sdk.SessionManager.inMemory();
@@ -263,10 +276,13 @@ export class PiSession extends Session {
             ...(this.opts.agentDir ? { agentDir: this.opts.agentDir } : {}),
         });
         this.session = session;
+        await this.bindExtensions(sdk, session);
         if (resuming) {
             const restored = itemsFromMessages(session.messages ?? []);
             this.items.push(...restored.items);
             this.tokens += restored.tokens;
+            if (restored.cost !== undefined)
+                this.cost = (this.cost ?? 0) + restored.cost;
             this.pushInfo(`resumed: ${restored.items.filter((i) => i.kind === "user").length} earlier prompts`);
             this.refreshStat(0);
         }
@@ -306,8 +322,11 @@ export class PiSession extends Session {
                         last.text = extractText(event.message.content);
                     last.streaming = false;
                     const usage = event.message?.usage;
-                    if (usage)
-                        this.tokens += (usage.input ?? 0) + (usage.output ?? 0);
+                    if (usage) {
+                        this.tokens += usageTokens(usage);
+                        if (typeof usage.cost?.total === "number")
+                            this.cost = (this.cost ?? 0) + usage.cost.total;
+                    }
                     if (!last.text)
                         this.items.pop(); // a turn that only called tools
                     this.emit();
@@ -377,15 +396,93 @@ export class PiSession extends Session {
         this.emit();
         return { editorText: r.editorText };
     }
+    /** where this agent's extensions show dialogs and messages (set by the app) */
+    uiHost;
+    /** statuses extensions keep up to date (ctx.ui.setStatus), shown in the winbar */
+    extensionStatus = new Map();
+    /**
+     * Hand pi's extensions their UI and start them (session_start), as pi's
+     * own modes do. Without this, an extension's confirm() always answers no
+     * and its notify() goes nowhere.
+     */
+    async bindExtensions(sdk, session) {
+        const THEME = Symbol.for("@mariozechner/pi-coding-agent:theme");
+        try {
+            if (!globalThis[THEME])
+                sdk.initTheme?.(undefined, false);
+        }
+        catch {
+            // extensions that style text get plain text
+        }
+        const ui = extensionUi(() => this.uiHost ?? this.fallbackUi, () => globalThis[THEME]);
+        try {
+            await session.bindExtensions({
+                uiContext: ui,
+                commandContextActions: {
+                    waitForIdle: () => session.agent.waitForIdle(),
+                    // one conversation per agent in vigent: :new starts another agent
+                    newSession: async () => ({ cancelled: true }),
+                    fork: async () => ({ cancelled: true }),
+                    switchSession: async () => ({ cancelled: true }),
+                    navigateTree: async (targetId) => {
+                        const r = await session.navigateTree(targetId, {});
+                        return { cancelled: r.cancelled };
+                    },
+                    reload: async () => {
+                        await session.reload();
+                    },
+                },
+                onError: (err) => this.pushInfo(`extension error (${shortExtPath(err?.extensionPath)}${err?.event ? `, ${err.event}` : ""}): ${err?.error ?? err}`),
+            });
+        }
+        catch (err) {
+            this.pushInfo(`pi extensions didn't start: ${String(err?.message ?? err)}`);
+        }
+        const failed = piResources(session).extensions.filter((e) => e.error);
+        for (const e of failed)
+            this.pushInfo(`extension ${shortExtPath(e.path)} didn't load: ${e.error}`);
+    }
+    /** with no screen to ask on: messages still reach the transcript, dialogs answer no */
+    fallbackUi = {
+        select: async () => undefined,
+        confirm: async () => false,
+        input: async () => undefined,
+        notify: (message) => this.pushInfo(message),
+        setStatus: (key, text) => this.setExtensionStatus(key, text),
+    };
+    setExtensionStatus(key, text) {
+        if (text)
+            this.extensionStatus.set(key, text);
+        else
+            this.extensionStatus.delete(key);
+        this.emit();
+    }
+    /** What pi loaded for this agent: extensions, their commands, skills, prompt templates, AGENTS.md files. */
+    resources() {
+        return this.session ? piResources(this.session) : undefined;
+    }
     send(text) {
         this.pushUser(text);
         this.setState("running");
+        const attached = expandPrompt(text, "pi", this.cwd);
+        if (attached.skipped.length)
+            this.pushInfo(`not attached: ${attached.skipped.join(", ")}`);
         this.ready
             // pi reports agent_end a moment before it accepts the next prompt (queued prompts hit this)
             .then(() => this.session.agent?.waitForIdle?.())
-            .then(() => this.session.prompt(text))
+            .then(() => this.session.prompt(attached.prompt))
+            // an extension command (/name) or a handled input runs no turn: nothing else will end it
+            .then(() => {
+            if (this.state === "running")
+                this.setState("idle");
+        })
             .catch((err) => {
-            this.pushInfo(`error: ${err?.message ?? err}`);
+            const text = String(err?.message ?? err);
+            // pi's own advice (/login, its docs paths) is for pi's TUI, not vigent: keep its first line
+            const key = /api key|login|auth/i.test(text);
+            this.pushInfo(`error: ${key ? text.split("\n")[0] : text}`);
+            if (key)
+                this.pushInfo(PI_KEY_HINT);
             this.setState("error");
         });
     }
@@ -403,6 +500,7 @@ export function itemsFromMessages(messages) {
     const items = [];
     const byCallId = new Map();
     let tokens = 0;
+    let cost;
     for (const m of messages) {
         if (m?.role === "user") {
             const text = extractText(m.content);
@@ -426,8 +524,11 @@ export function itemsFromMessages(messages) {
                 if (b.id)
                     byCallId.set(b.id, item);
             }
-            if (m.usage)
-                tokens += (m.usage.input ?? 0) + (m.usage.output ?? 0);
+            if (m.usage) {
+                tokens += usageTokens(m.usage);
+                if (typeof m.usage.cost?.total === "number")
+                    cost = (cost ?? 0) + m.usage.cost.total;
+            }
             const err = piError(m);
             if (err)
                 items.push({ kind: "info", text: err });
@@ -438,8 +539,14 @@ export function itemsFromMessages(messages) {
                 item.tool.output = extractText(m.content);
         }
     }
-    return { items, tokens };
+    return { items, tokens, cost };
 }
+/** pi's usage: every token the request read or wrote, cached ones included (like Claude Code's count) */
+function usageTokens(u) {
+    return u.totalTokens ?? (u.input ?? 0) + (u.output ?? 0) + (u.cacheRead ?? 0) + (u.cacheWrite ?? 0);
+}
+/** What to do when pi can't get through: this agent stays on pi, so start one elsewhere. */
+export const PI_KEY_HINT = "this agent runs on pi, and pi has no working API key. Agents keep the engine they started on: :new <task> starts one on the default engine (:engine picks it, e.g. Claude Code or Codex with your existing login), and :kill removes this one.";
 /**
  * The error of a reply whose request failed (pi ends it with stopReason
  * "error" and an errorMessage), with a hint when the key or login was refused.
@@ -449,8 +556,7 @@ export function piError(message) {
         return undefined;
     const text = String(message.errorMessage ?? "").trim() || "the request failed";
     const auth = /\b(401|403)\b|auth|api[ _-]?key|unauthori[sz]ed|forbidden|credential|expired|login/i.test(text);
-    const hint = auth ? " · pi's API key or login was refused; :checkhealth shows the engines, and :new <task> --engine claude starts one on Claude Code" : "";
-    return `error: ${text}${hint}`;
+    return auth ? `error: ${text}\n${PI_KEY_HINT}` : `error: ${text}`;
 }
 function extractText(content) {
     if (typeof content === "string")
@@ -472,7 +578,7 @@ function summarizeArgs(args) {
 }
 /** A pi-ai model from "provider/model", or a bare id (Anthropic's). Undefined when pi doesn't know it. */
 export async function piModel(id) {
-    const ai = await import("@mariozechner/pi-ai");
+    const ai = await loadPiAi();
     const slash = id.indexOf("/");
     const [provider, modelId] = slash > 0 ? [id.slice(0, slash), id.slice(slash + 1)] : ["anthropic", id];
     try {
@@ -482,3 +588,8 @@ export async function piModel(id) {
         return undefined;
     }
 }
+/** ~/.pi/agent/extensions/guard.ts → extensions/guard.ts */
+function shortExtPath(p) {
+    const parts = String(p ?? "extension").split(/[\\/]/);
+    return parts.slice(-2).join("/");
+}

package/dist/settings.js

@@ -7,7 +7,7 @@
  * Changes apply at once. A key row waits for the new keys: type them, then
  * Enter (Esc cancels).
  */
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "./tui.js";
 import { keyFromInput } from "./keys.js";
 import { RESET } from "./theme.js";
 export class SettingsFloat {

package/dist/templates.js

@@ -0,0 +1,125 @@
+/**
+ * Session templates: a prompt you start agents with often, with the engine,
+ * model and effort it should run on.
+ *
+ *   [templates.fix]
+ *   prompt = "Find and fix this bug: {task}. Reproduce it with a failing test first."
+ *   engine = "claude"
+ *   effort = "high"
+ *
+ * `:new -t fix the cart total is off` starts an agent and sends the prompt,
+ * with `{task}` replaced by what you typed. A few are built in; a template
+ * in config.toml with the same name replaces the built-in one.
+ */
+import { EFFORTS } from "./choices.js";
+import { isEngineId } from "./engines.js";
+export const BUILTIN_TEMPLATES = [
+    {
+        name: "fix",
+        description: "reproduce a bug with a failing test, then fix it",
+        prompt: "Find and fix this bug: {task}\n\nFirst reproduce it with a failing test. Then make the smallest change that makes the test pass, and run the whole test suite before you finish.",
+    },
+    {
+        name: "test",
+        description: "write tests in the project's own style",
+        prompt: "Write tests for {task}. Cover the usual cases and the edge cases, follow the style of the tests already in the project, and run them. Don't change the code under test; if a test finds a bug, say so.",
+    },
+    {
+        name: "review",
+        description: "review this branch's work; changes nothing",
+        prompt: "Review the work on this branch: compare it with the branch it started from using git. Look for bugs, missing tests and code that's hard to follow.{task}\n\nList what you find by file and line, most serious first. Don't change any files.",
+    },
+    {
+        name: "explain",
+        description: "how something works and where it lives; changes nothing",
+        prompt: "Explain {task}: how it works, where it lives in the code, and what would break if it changed. Don't change any files.",
+    },
+];
+/** Whether the prompt has a place for the task. */
+export function needsTask(t) {
+    return t.prompt.includes("{task}");
+}
+/**
+ * The prompt for a task. `{task}` takes the task; a template without one gets
+ * the task added after it. The review template's `{task}` is optional focus.
+ */
+export function fillTemplate(t, task) {
+    const text = task.trim();
+    if (!needsTask(t))
+        return text ? `${t.prompt}\n\n${text}` : t.prompt;
+    if (t.name === "review" && t.builtin)
+        return t.prompt.replace("{task}", text ? ` Focus on: ${text}.` : "");
+    return t.prompt.split("{task}").join(text);
+}
+/** Built-ins first, then yours (yours replace a built-in of the same name), in config order. */
+export function allTemplates(user) {
+    const out = BUILTIN_TEMPLATES.map((t) => user[t.name] ?? { ...t, builtin: true });
+    for (const t of Object.values(user))
+        if (!BUILTIN_TEMPLATES.some((b) => b.name === t.name))
+            out.push(t);
+    return out;
+}
+/** `[templates]` from config.toml; problems become warnings, never errors. */
+export function parseTemplates(value, warnings) {
+    const out = {};
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        warnings.push("config: [templates] should be a table");
+        return out;
+    }
+    for (const [name, raw] of Object.entries(value)) {
+        const where = `config [templates.${name}]`;
+        if (!/^[\w-]+$/.test(name)) {
+            warnings.push(`${where}: a template name is letters, digits, - and _`);
+            continue;
+        }
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+            warnings.push(`${where} should be a table`);
+            continue;
+        }
+        const r = raw;
+        if (typeof r.prompt !== "string" || !r.prompt.trim()) {
+            warnings.push(`${where}: 'prompt' is required`);
+            continue;
+        }
+        const t = { name, prompt: r.prompt.trim() };
+        for (const [k, v] of Object.entries(r)) {
+            switch (k) {
+                case "prompt":
+                    break;
+                case "description":
+                case "model":
+                    if (typeof v === "string")
+                        t[k] = v;
+                    else
+                        warnings.push(`${where}: '${k}' should be a string`);
+                    break;
+                case "engine":
+                    if (typeof v === "string" && isEngineId(v))
+                        t.engine = v;
+                    else
+                        warnings.push(`${where}: 'engine' should be "pi", "claude", "codex" or "opencode"`);
+                    break;
+                case "worktree":
+                    if (typeof v === "boolean")
+                        t.worktree = v;
+                    else
+                        warnings.push(`${where}: 'worktree' should be true or false`);
+                    break;
+                case "effort":
+                    if (typeof v === "string")
+                        t.effort = v;
+                    else
+                        warnings.push(`${where}: 'effort' should be a string`);
+                    break;
+                default:
+                    warnings.push(`${where}: unknown option '${k}'`);
+            }
+        }
+        if (t.effort && t.engine && !EFFORTS[t.engine].includes(t.effort)) {
+            warnings.push(`${where}: 'effort' should be one of ${EFFORTS[t.engine].join(", ")}`);
+            delete t.effort;
+        }
+        out[name] = t;
+    }
+    return out;
+}

package/dist/theme.js

@@ -105,6 +105,8 @@ const LINKS = {
     VigentSidebar: "NeoTreeNormal",
     VigentIndent: "NeoTreeIndentMarker",
     VigentUser: "Title",
+    /** `@path` in a prompt */
+    VigentMention: "Directory",
     VigentTool: "Function",
     VigentToolOutput: "Comment",
     VigentSpinner: "WarningMsg",

package/dist/tui.js

@@ -0,0 +1,13 @@
+/**
+ * The parts of pi-tui vigent uses, imported from their own modules.
+ *
+ * pi-tui's index also loads its editor, markdown (marked), image and
+ * autocomplete components, none of which vigent draws; skipping them makes
+ * every start faster. Everything from pi-tui goes through this file, so a
+ * change in its layout is fixed here once.
+ */
+export { fuzzyFilter } from "@mariozechner/pi-tui/dist/fuzzy.js";
+export { parseKey } from "@mariozechner/pi-tui/dist/keys.js";
+export { ProcessTerminal } from "@mariozechner/pi-tui/dist/terminal.js";
+export { TUI } from "@mariozechner/pi-tui/dist/tui.js";
+export { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@mariozechner/pi-tui/dist/utils.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vigent/cli",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "A vim-style terminal app for running coding agents side by side, each in its own git worktree. Built on pi.",
   "keywords": [
     "vim",
@@ -15,7 +15,7 @@
     "llm",
     "cli"
   ],
-  "homepage": "https://github.com/farming-labs/vigent#readme",
+  "homepage": "https://vigent.farming-labs.dev",
   "bugs": {
     "url": "https://github.com/farming-labs/vigent/issues"
   },
@@ -27,7 +27,7 @@
   "author": "KinfeMichael Tariku",
   "type": "module",
   "bin": {
-    "vigent": "./dist/cli.js"
+    "vigent": "./dist/main.js"
   },
   "files": [
     "dist",
@@ -48,8 +48,6 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@mariozechner/pi-ai": "^0.73.1",
-    "@mariozechner/pi-coding-agent": "^0.73.1",
     "@mariozechner/pi-tui": "^0.73.1",
     "smol-toml": "^1.9.1"
   },
@@ -58,6 +56,8 @@
     "typescript": "^7.0.2"
   },
   "optionalDependencies": {
+    "@mariozechner/pi-ai": "^0.73.1",
+    "@mariozechner/pi-coding-agent": "^0.73.1",
     "riftri": "^0.6.7"
   },
   "publishConfig": {