@vigent/cli 0.2.2 → 0.3.0

package/dist/serve.js

@@ -0,0 +1,267 @@
+/**
+ * `:serve`: follow your agents from your phone.
+ *
+ * A small HTTP server on your machine: a page that lists the agents and shows
+ * a transcript as it streams, where you can send a prompt or stop an agent.
+ * It starts only when you ask (`:serve`, or `vigent --serve`) and stops with
+ * `:serve stop` or when vigent quits.
+ *
+ * Every API call needs the access code shown in vigent (8 characters, new
+ * each time). Prompts and stops need it in a header, so another web page
+ * can't send them from your browser. After 10 wrong codes the server stops
+ * answering until you start it again. It's plain HTTP: use it on a network
+ * you trust (home Wi-Fi, a VPN such as Tailscale), not on public Wi-Fi.
+ */
+import { randomInt, timingSafeEqual } from "node:crypto";
+import * as http from "node:http";
+import * as os from "node:os";
+import { ENGINE_NAMES } from "./engines.js";
+import { servePage } from "./serve-page.js";
+const CODE_ALPHABET = "abcdefghjkmnpqrstuvwxyz23456789"; // no 0/o, 1/l/i: easy to type on a phone
+const MAX_FAILURES = 10;
+const MAX_PROMPT = 20_000;
+/** A fresh access code, like "k3x9-q2m7". */
+export function newAccessCode() {
+    const pick = () => CODE_ALPHABET[randomInt(CODE_ALPHABET.length)];
+    return `${Array.from({ length: 4 }, pick).join("")}-${Array.from({ length: 4 }, pick).join("")}`;
+}
+/** This machine's addresses a phone on the same network can reach (IPv4, not loopback). */
+export function lanAddresses() {
+    const out = [];
+    for (const list of Object.values(os.networkInterfaces())) {
+        for (const a of list ?? [])
+            if (a.family === "IPv4" && !a.internal)
+                out.push(a.address);
+    }
+    return out;
+}
+function same(a, b) {
+    const x = Buffer.from(a);
+    const y = Buffer.from(b);
+    return x.length === y.length && timingSafeEqual(x, y);
+}
+function agentSummary(s, unread) {
+    const st = s.worktree?.stat;
+    const last = [...s.items].reverse().find((i) => i.kind === "agent" || i.kind === "user");
+    return {
+        id: s.id,
+        name: s.name,
+        engine: s.engine,
+        engineName: ENGINE_NAMES[s.engine],
+        model: s.model,
+        effort: s.effort,
+        state: s.state,
+        branch: s.worktree?.branch,
+        added: st?.added ?? 0,
+        removed: st?.removed ?? 0,
+        tokens: s.tokens,
+        cost: s.cost,
+        queued: s.queue.length,
+        unread,
+        version: s.version,
+        last: last ? { kind: last.kind, text: preview(last.text) } : undefined,
+    };
+}
+/** a reply as one plain line for the agent list: no markdown marks, no code fences */
+function preview(text) {
+    return text
+        .replace(/\x60\x60\x60[^\n]*\n?/g, " ")
+        .replace(/\*\*|__|\x60/g, "")
+        .replace(/^#+ /gm, "")
+        .replace(/\s+/g, " ")
+        .trim()
+        .slice(0, 160);
+}
+function itemJson(i) {
+    return {
+        kind: i.kind,
+        text: i.text.length > 50_000 ? `${i.text.slice(0, 50_000)}\n…` : i.text,
+        streaming: i.streaming || undefined,
+        tool: i.tool
+            ? { name: i.tool.name, summary: i.tool.summary, output: i.tool.output.length > 4000 ? `${i.tool.output.slice(0, 4000)}\n…` : i.tool.output }
+            : undefined,
+    };
+}
+export function startServer(host, opts = {}) {
+    const code = opts.code ?? newAccessCode();
+    const bind = opts.host ?? "0.0.0.0";
+    let failures = 0;
+    let locked = false;
+    const streams = new Set();
+    const watching = new Map();
+    let pending;
+    let everConnected = false;
+    const broadcast = () => {
+        if (pending)
+            return;
+        // coalesce: a streaming reply changes many times a second
+        pending = setTimeout(() => {
+            pending = undefined;
+            const data = JSON.stringify({ agents: host.sessions().map((s) => agentSummary(s, host.isUnread(s))) });
+            for (const res of streams)
+                res.write(`event: agents\ndata: ${data}\n\n`);
+        }, 120);
+    };
+    const sync = () => {
+        const now = new Set(host.sessions());
+        for (const [s, off] of watching) {
+            if (!now.has(s)) {
+                off();
+                watching.delete(s);
+            }
+        }
+        for (const s of now)
+            if (!watching.has(s))
+                watching.set(s, s.onChange(broadcast));
+        broadcast();
+    };
+    const authorized = (req, url, headerOnly) => {
+        if (locked)
+            return false;
+        const header = /^Bearer (.+)$/.exec(req.headers.authorization ?? "")?.[1];
+        const given = header ?? (headerOnly ? undefined : (url.searchParams.get("code") ?? undefined));
+        if (given && same(given.trim().toLowerCase(), code))
+            return true;
+        if (given !== undefined && ++failures >= MAX_FAILURES) {
+            locked = true;
+            host.notify(`:serve stopped answering after ${MAX_FAILURES} wrong access codes (:serve stop, then :serve, for a new one)`);
+        }
+        return false;
+    };
+    const send = (res, status, body) => {
+        res.writeHead(status, { "content-type": "application/json; charset=utf-8", "cache-control": "no-store" });
+        res.end(JSON.stringify(body));
+    };
+    const readBody = (req) => new Promise((resolve, reject) => {
+        let size = 0;
+        const chunks = [];
+        req.on("data", (c) => {
+            size += c.length;
+            if (size > MAX_PROMPT * 4) {
+                reject(new Error("too large"));
+                req.destroy();
+            }
+            else
+                chunks.push(c);
+        });
+        req.on("end", () => {
+            try {
+                resolve(JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"));
+            }
+            catch {
+                reject(new Error("not JSON"));
+            }
+        });
+        req.on("error", reject);
+    });
+    const server = http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? "/", "http://vigent");
+        const route = `${req.method} ${url.pathname}`;
+        try {
+            if (route === "GET /" || route === "GET /index.html") {
+                res.writeHead(200, {
+                    "content-type": "text/html; charset=utf-8",
+                    "cache-control": "no-store",
+                    "content-security-policy": "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'; img-src data:",
+                    "referrer-policy": "no-referrer",
+                });
+                res.end(servePage(host.project(), host.palette()));
+                return;
+            }
+            if (!url.pathname.startsWith("/api/"))
+                return send(res, 404, { error: "not found" });
+            // reads may carry the code in the URL (EventSource can't set headers); changes need the header
+            const writes = req.method !== "GET";
+            if (!authorized(req, url, writes))
+                return send(res, locked ? 423 : 401, { error: locked ? "locked: start :serve again in vigent" : "wrong access code" });
+            if (route === "GET /api/state") {
+                return send(res, 200, { project: host.project(), agents: host.sessions().map((s) => agentSummary(s, host.isUnread(s))) });
+            }
+            if (route === "GET /api/events") {
+                res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-store", connection: "keep-alive" });
+                res.write(": vigent\n\n");
+                streams.add(res);
+                if (!everConnected) {
+                    everConnected = true;
+                    host.notify("a phone is following (:serve)");
+                }
+                const beat = setInterval(() => res.write(": beat\n\n"), 15_000);
+                req.on("close", () => {
+                    clearInterval(beat);
+                    streams.delete(res);
+                });
+                broadcast();
+                return;
+            }
+            if (route === "POST /api/agents") {
+                const body = await readBody(req);
+                const text = typeof body.text === "string" ? body.text.trim() : "";
+                if (!text || text.length > MAX_PROMPT)
+                    return send(res, 400, { error: "a task, up to 20000 characters" });
+                const s = host.startAgent(text);
+                if (!s)
+                    return send(res, 409, { error: "couldn't start an agent (see vigent)" });
+                s.submit(text);
+                host.notify(`'${s.name}' started from your phone`);
+                sync();
+                return send(res, 200, { id: s.id });
+            }
+            const m = /^\/api\/agents\/(\d+)(\/prompt|\/stop)?$/.exec(url.pathname);
+            const s = m ? host.sessions().find((x) => x.id === Number(m[1])) : undefined;
+            if (!m || !s)
+                return send(res, 404, { error: "no such agent" });
+            if (req.method === "GET" && !m[2]) {
+                return send(res, 200, { agent: agentSummary(s, host.isUnread(s)), items: s.items.map(itemJson) });
+            }
+            if (req.method === "POST" && m[2] === "/prompt") {
+                const body = await readBody(req);
+                const text = typeof body.text === "string" ? body.text.trim() : "";
+                if (!text || text.length > MAX_PROMPT)
+                    return send(res, 400, { error: "a prompt, up to 20000 characters" });
+                const waiting = s.submit(text);
+                host.notify(`'${s.name}' got a prompt from your phone${waiting > 0 ? ` (queued, ${waiting} waiting)` : ""}`);
+                return send(res, 200, { queued: waiting });
+            }
+            if (req.method === "POST" && m[2] === "/stop") {
+                if (s.state === "running")
+                    s.abort();
+                return send(res, 200, { state: s.state });
+            }
+            return send(res, 405, { error: "not allowed" });
+        }
+        catch (err) {
+            if (!res.headersSent)
+                send(res, 400, { error: String(err.message ?? err) });
+        }
+    });
+    return new Promise((resolve, reject) => {
+        server.once("error", reject);
+        server.listen(opts.port ?? 8377, bind, () => {
+            server.off("error", reject);
+            const port = server.address().port;
+            const local = bind === "127.0.0.1" || bind === "localhost";
+            const urls = [...(local ? [] : lanAddresses().map((a) => `http://${a}:${port}/`)), `http://127.0.0.1:${port}/`];
+            sync();
+            resolve({
+                port,
+                host: bind,
+                code,
+                urls,
+                clients: () => streams.size,
+                sync,
+                close: () => new Promise((done) => {
+                    if (pending)
+                        clearTimeout(pending);
+                    for (const off of watching.values())
+                        off();
+                    watching.clear();
+                    for (const r of streams)
+                        r.end();
+                    streams.clear();
+                    server.close(() => done());
+                    server.closeAllConnections?.();
+                }),
+            });
+        });
+    });
+}

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,22 +276,28 @@ 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);
         }
         session.subscribe((event) => this.onEvent(event));
     }
+    /** the run ended on a failed request (shown as an error, not as silence) */
+    failed = false;
     onEvent(event) {
         switch (event.type) {
             case "agent_start":
+                this.failed = false;
                 this.setState("running");
                 break;
             case "agent_end":
-                this.setState("idle");
+                this.setState(this.failed ? "error" : "idle");
                 this.refreshStat(0);
                 break;
             case "message_start": {
@@ -303,12 +322,21 @@ 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();
                 }
+                // a failed request ends the reply with an error instead of throwing: say so
+                const err = piError(event.message);
+                if (err) {
+                    this.failed = true;
+                    this.pushInfo(err);
+                }
                 break;
             }
             case "tool_execution_start": {
@@ -368,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");
         });
     }
@@ -394,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);
@@ -417,8 +524,14 @@ 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 });
         }
         else if (m?.role === "toolResult") {
             const item = byCallId.get(m.toolCallId);
@@ -426,7 +539,24 @@ 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.
+ */
+export function piError(message) {
+    if (message?.role !== "assistant" || message.stopReason !== "error")
+        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);
+    return auth ? `error: ${text}\n${PI_KEY_HINT}` : `error: ${text}`;
 }
 function extractText(content) {
     if (typeof content === "string")
@@ -448,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 {
@@ -458,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";