@vigent/cli 0.2.3 → 0.3.1

package/dist/attach.js

@@ -0,0 +1,102 @@
+/**
+ * `@path` in a prompt attaches a file from the agent's folder.
+ *
+ * Each engine gets it its own way: Claude Code reads `@path` in a prompt
+ * itself; OpenCode takes the files with `-f`; for Codex and pi, vigent adds
+ * the file's contents under the prompt. The transcript shows what you typed.
+ */
+import { execFile } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/** files larger than this aren't inlined (Codex, pi) */
+export const MAX_INLINE_BYTES = 100 * 1024;
+/** The files an agent can be pointed at: tracked and new ones, without what .gitignore hides. */
+export function listFiles(cwd) {
+    return new Promise((resolve) => {
+        execFile("git", ["ls-files", "--cached", "--others", "--exclude-standard", "-z"], { cwd, maxBuffer: 64 * 1024 * 1024 }, (err, stdout) => {
+            if (err)
+                return resolve(walk(cwd));
+            const files = [...new Set(String(stdout).split("\0").filter(Boolean))].filter((f) => fs.existsSync(path.join(cwd, f)));
+            resolve(files.sort(byDepthThenName));
+        });
+    });
+}
+/** Not a git repository: a shallow walk, skipping the usual heavy folders. */
+function walk(cwd, max = 5000) {
+    const out = [];
+    const skip = new Set(["node_modules", ".git", "dist", "build", "target", ".next", ".venv", "venv"]);
+    const visit = (dir, depth) => {
+        if (out.length >= max || depth > 6)
+            return;
+        let entries = [];
+        try {
+            entries = fs.readdirSync(path.join(cwd, dir), { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const rel = dir ? `${dir}/${e.name}` : e.name;
+            if (e.isDirectory()) {
+                if (!skip.has(e.name) && !e.name.startsWith("."))
+                    visit(rel, depth + 1);
+            }
+            else if (e.isFile())
+                out.push(rel);
+        }
+    };
+    visit("", 0);
+    return out.sort(byDepthThenName);
+}
+function byDepthThenName(a, b) {
+    return a.split("/").length - b.split("/").length || a.localeCompare(b);
+}
+/** a path that can follow `@`: letters, digits, `_ . / @ + -`, not ending in `.` or `@` (so "see @a.js." works) */
+const PATH = String.raw `[\p{L}\p{N}_./@+-]*[\p{L}\p{N}_/+-]`;
+/** `@path` at the start of a word; group 1 is the path */
+export const MENTION = new RegExp(String.raw `(?:^|(?<=\s))@(${PATH})`, "gu");
+/** Whether `@file` would read back as this file (names with spaces can't). */
+export function mentionable(file) {
+    return new RegExp(`^${PATH}$`, "u").test(file);
+}
+/** The `@path` mentions in a prompt that name files in `cwd` (in order, once each). */
+export function mentions(prompt, cwd) {
+    const out = [];
+    for (const m of prompt.matchAll(MENTION)) {
+        const rel = m[1];
+        const abs = path.resolve(cwd, rel);
+        if (!abs.startsWith(path.resolve(cwd) + path.sep) && abs !== path.resolve(cwd))
+            continue; // stays inside the folder
+        if (!out.includes(rel) && fs.existsSync(abs) && fs.statSync(abs).isFile())
+            out.push(rel);
+    }
+    return out;
+}
+/** Turn a prompt with `@path` mentions into what this engine needs. */
+export function expandPrompt(prompt, engine, cwd) {
+    const files = mentions(prompt, cwd);
+    if (files.length === 0)
+        return { prompt, files: [], skipped: [] };
+    if (engine === "claude")
+        return { prompt, files: [], skipped: [] }; // Claude Code reads @path itself
+    if (engine === "opencode")
+        return { prompt, files: files.map((f) => path.join(cwd, f)), skipped: [] };
+    const blocks = [];
+    const skipped = [];
+    for (const f of files) {
+        const buf = fs.readFileSync(path.join(cwd, f));
+        if (buf.includes(0)) {
+            skipped.push(`${f} (binary)`);
+            continue;
+        }
+        if (buf.length > MAX_INLINE_BYTES) {
+            skipped.push(`${f} (${Math.round(buf.length / 1024)} KB, over ${MAX_INLINE_BYTES / 1024} KB)`);
+            continue;
+        }
+        const text = buf.toString("utf8");
+        blocks.push(`<file path="${f}">\n${text}${text.endsWith("\n") ? "" : "\n"}</file>`);
+    }
+    if (blocks.length === 0)
+        return { prompt, files: [], skipped };
+    return { prompt: `${prompt}\n\nAttached files:\n\n${blocks.join("\n\n")}`, files: [], skipped };
+}

package/dist/choices.js

@@ -6,6 +6,7 @@
  */
 import { execFile } from "node:child_process";
 import { ENGINE_BINS } from "./engines.js";
+import { loadPiAi } from "./pi-sdk.js";
 /** Reasoning effort / thinking levels each engine accepts. */
 export const EFFORTS = {
     pi: ["off", "minimal", "low", "medium", "high", "xhigh"],
@@ -46,7 +47,9 @@ export async function modelChoices(engine, env = process.env) {
         case "opencode":
             return [{ value: "default", note: "OpenCode's own choice" }, ...(await opencodeModels(env)).map((value) => ({ value }))];
         case "pi": {
-            const ai = await import("@mariozechner/pi-ai");
+            const ai = await loadPiAi().catch(() => undefined);
+            if (!ai)
+                return [{ value: "default", note: "pi isn't installed" }];
             const providers = Object.keys(PI_KEYS).filter((p) => PI_KEYS[p].some((k) => env[k]));
             const out = [];
             for (const provider of providers.length ? providers : ["anthropic"]) {

package/dist/cli-engines.js

@@ -10,6 +10,7 @@
  */
 import { spawn } from "node:child_process";
 import * as fs from "node:fs";
+import { expandPrompt } from "./attach.js";
 import { ENGINE_BINS, ENGINE_NAMES } from "./engines.js";
 import { Session } from "./session.js";
 // ---------------------------------------------------------------------------
@@ -76,8 +77,9 @@ export const claudeAdapter = {
                 case "result": {
                     const u = e.usage ?? {};
                     const tokens = (u.input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.output_tokens ?? 0);
-                    if (tokens)
-                        out.push({ type: "usage", tokens });
+                    const cost = typeof e.total_cost_usd === "number" ? e.total_cost_usd : undefined;
+                    if (tokens || cost !== undefined)
+                        out.push({ type: "usage", tokens, ...(cost !== undefined ? { cost } : {}) });
                     if (e.session_id)
                         out.push({ type: "session", id: e.session_id });
                     const ok = !e.is_error && e.subtype === "success";
@@ -209,6 +211,7 @@ export const opencodeAdapter = {
             ...(o.model ? ["-m", o.model] : []),
             ...(o.effort ? ["--variant", o.effort] : []),
             ...(o.resumeId ? ["--session", o.resumeId] : []),
+            ...(o.files ?? []).flatMap((f) => ["-f", f]),
             "--",
             prompt,
         ];
@@ -238,8 +241,9 @@ export const opencodeAdapter = {
                 case "step_finish": {
                     const t = part.tokens ?? {};
                     const tokens = (t.input ?? 0) + (t.output ?? 0) + (t.reasoning ?? 0) + (t.cache?.read ?? 0) + (t.cache?.write ?? 0);
-                    if (tokens)
-                        out.push({ type: "usage", tokens });
+                    const cost = typeof part.cost === "number" ? part.cost : undefined;
+                    if (tokens || cost !== undefined)
+                        out.push({ type: "usage", tokens, ...(cost !== undefined ? { cost } : {}) });
                     break;
                 }
                 case "error": {
@@ -302,8 +306,12 @@ export class CliSession extends Session {
         this.pushUser(text);
         this.setState("running");
         this.aborted = false;
-        const args = this.adapter.args(text, {
+        const attached = expandPrompt(text, this.adapter.id, this.cwd);
+        if (attached.skipped.length)
+            this.pushInfo(`not attached: ${attached.skipped.join(", ")}`);
+        const args = this.adapter.args(attached.prompt, {
             cwd: this.cwd,
+            files: attached.files,
             model: this.requestedModel,
             effort: this.effort,
             resumeId: this.resumeId,
@@ -381,6 +389,8 @@ export class CliSession extends Session {
                 }
                 case "usage":
                     this.tokens += ev.tokens;
+                    if (ev.cost !== undefined)
+                        this.cost = (this.cost ?? 0) + ev.cost;
                     this.emit();
                     break;
                 case "error":

package/dist/cli.js

@@ -3,9 +3,10 @@
 import { execFileSync } from "node:child_process";
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { ProcessTerminal, TUI } from "@mariozechner/pi-tui";
-import { loadAgentMeta, restorableAgents, saveAgentMeta, sessionDir } from "./agents.js";
+import { ProcessTerminal, TUI } from "./tui.js";
+import { loadAgentMeta, reopenableAgents, saveAgentMeta, sessionDir } from "./agents.js";
 import { App } from "./app.js";
+import { FOCUS_REPORTING_OFF, FOCUS_REPORTING_ON } from "./notify.js";
 import { staleBuild, VERSION_TEXT } from "./version.js";
 import { CliSession } from "./cli-engines.js";
 import { defaultEngine, detectEngines, ENGINE_BINS, isEngineId, onPath, piConnected, quickEngines } from "./engines.js";
@@ -23,6 +24,7 @@ const HELP = `vigent — vim-native agent orchestrator (pi engine)
 usage:
   vigent --version                           which vigent this is (and the commit, from a clone)
   vigent [folder] [--demo] [--theme <name>] [--model <id>] [--engine pi|claude|codex|opencode]
+  vigent --serve [--local]                   also follow your agents from your phone (:serve)
 
 engines (what runs new agents; :checkhealth shows which are signed in):
   pi        built in, uses ANTHROPIC_API_KEY / OPENAI_API_KEY / ... or pi's login
@@ -313,6 +315,7 @@ async function main() {
         },
     });
     // model and effort for new agents, per engine, from [engines.<id>]
+    app.templates = config.templates;
     for (const [id, opts] of Object.entries(config.engines)) {
         if (opts?.model)
             app.newAgentModel[id] = opts.model;
@@ -331,7 +334,7 @@ async function main() {
         saveAgentMeta(wt, {
             ...meta,
             model: s instanceof CliSession ? (requested ?? "") : s.model,
-            ...(s instanceof CliSession ? { requestedModel: requested } : {}),
+            ...(s instanceof CliSession ? { requestedModel: requested, usage: { tokens: s.tokens, ...(s.cost !== undefined ? { cost: s.cost } : {}) } } : {}),
             effort: s.effort,
         });
     };
@@ -365,8 +368,13 @@ async function main() {
     /** Reopen a saved agent with the engine it was started with. */
     const reopen = (meta, worktree) => {
         const engine = meta.engine && isEngineId(meta.engine) ? meta.engine : "pi";
-        if (engine !== "pi")
-            return cliSession(meta.name, engine, meta.requestedModel, worktree.path, worktree, meta.resumeId, meta.effort);
+        if (engine !== "pi") {
+            const s = cliSession(meta.name, engine, meta.requestedModel, worktree.path, worktree, meta.resumeId, meta.effort);
+            // the CLI keeps the conversation; vigent keeps the running totals
+            s.tokens = meta.usage?.tokens ?? 0;
+            s.cost = meta.usage?.cost;
+            return s;
+        }
         return new PiSession(meta.name, meta.model, { cwd: worktree.path, worktree, sessionDir: sessionDir(worktree.path), effort: meta.effort });
     };
     app.attachSession = (wt) => {
@@ -389,6 +397,7 @@ async function main() {
             s.abort();
             s.dispose();
         }
+        terminal.write(FOCUS_REPORTING_OFF);
         tui.stop();
         process.exit(0);
     };
@@ -403,17 +412,13 @@ async function main() {
     }
     else if (root && config.worktree.enabled) {
         // reopen the agents that were running when vigent last quit
-        const agents = restorableAgents(root, config.worktree);
-        // riftri views on OverlayFS lose their mount on reboot: repair them before an agent runs there
-        const views = prepareViews(root, agents.map((a) => a.worktree.path));
-        for (const { meta, worktree } of agents) {
-            const view = views.get(worktree.path);
-            if (view && !view.ready) {
-                warnings.push(`couldn't reopen '${meta.name}': ${view.reason}`);
-                continue;
-            }
+        // riftri views on OverlayFS lose their mount on reboot: they're repaired before any agent's record is read
+        const { agents, blocked } = reopenableAgents(root, config.worktree, prepareViews);
+        for (const b of blocked)
+            warnings.push(`couldn't reopen the agent in ${b.path}: ${b.reason}`);
+        for (const { meta, worktree, backend } of agents) {
             try {
-                app.addSession(reopen(meta, { ...worktree, riftri: view?.backend }), false);
+                app.addSession(reopen(meta, { ...worktree, riftri: backend }), false);
             }
             catch (err) {
                 warnings.push(`couldn't reopen '${meta.name}': ${err.message}`);
@@ -428,6 +433,8 @@ async function main() {
     tui.setFocus(app);
     terminal.setTitle("vigent");
     tui.start();
+    // focus reports let a notification skip the agent you're looking at
+    terminal.write(FOCUS_REPORTING_ON);
     if (warnings.length > 0)
         app.notify(warnings.join(" · "));
     if (isFollow(themeName)) {
@@ -438,6 +445,9 @@ async function main() {
         });
     }
     tui.requestRender(true);
+    // follow from your phone from the start (same as :serve)
+    if (argv.includes("--serve"))
+        void app.execServe(argv.includes("--local") ? "local" : "");
     return undefined;
 }
 main()

package/dist/config.js

@@ -15,10 +15,12 @@
  *   CursorLine = "guibg=#2a2f3a"
  *   VigentSidebar = { link = "NormalFloat" }
  */
+import { NOTIFY_MODES } from "./notify.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseToml } from "smol-toml";
 import { EFFORTS } from "./choices.js";
+import { parseTemplates } from "./templates.js";
 import { ICON_SETS } from "./icons.js";
 import { isEngineId } from "./engines.js";
 import { WORKTREE_BACKENDS } from "./riftri.js";
@@ -36,13 +38,14 @@ export const DEFAULT_UI = {
     termguicolors: process.env.TERM_PROGRAM !== "Apple_Terminal",
     transparent: "auto",
     whichkey: true,
+    notify: "auto",
 };
 export function configPath() {
     return path.join(configDir(), "config.toml");
 }
 /** Load the config file. Problems become warnings so a typo never stops vigent from starting. */
 export function loadConfig(file = configPath()) {
-    const config = { ui: { ...DEFAULT_UI }, highlights: {}, keys: {}, worktree: { ...DEFAULT_WORKTREE }, engines: {} };
+    const config = { ui: { ...DEFAULT_UI }, highlights: {}, keys: {}, worktree: { ...DEFAULT_WORKTREE }, engines: {}, templates: {} };
     const warnings = [];
     if (!fs.existsSync(file))
         return { config, warnings };
@@ -104,6 +107,9 @@ export function loadConfig(file = configPath()) {
                     config.engines[id] = e;
                 }
                 break;
+            case "templates":
+                config.templates = parseTemplates(value, warnings);
+                break;
             case "keys":
                 if (!value || typeof value !== "object" || Array.isArray(value)) {
                     warnings.push("config: [keys] should be a table");
@@ -200,6 +206,7 @@ const ALIASES = {
     transp: "transparent",
     whichkey: "whichkey",
     wk: "whichkey",
+    notify: "notify",
 };
 /** Set one option from a config value. Returns an error message, or undefined on success. */
 export function setOption(ui, name, value) {
@@ -223,6 +230,11 @@ export function setOption(ui, name, value) {
             ui.sidebar_width = n;
             return;
         }
+        case "notify":
+            if (!NOTIFY_MODES.includes(value))
+                return `'${name}' should be "auto", "bell", "desktop" or "off"`;
+            ui.notify = value;
+            return;
         case "icons":
             if (!ICON_SETS.includes(value))
                 return `'${name}' should be "unicode", "nerd" or "ascii"`;
@@ -327,7 +339,7 @@ theme = "default"
 # --- Engines ---------------------------------------------------------------
 # What runs new agents: "pi" (built in), or a coding-agent CLI you already
 # have installed and signed in: "claude" (Claude Code), "codex", "opencode".
-# "auto" picks pi if it has an API key, else the first signed-in CLI.
+# "auto" picks the first signed-in CLI (your own login), else pi if it has an API key.
 # Per agent: :new fix the race --engine codex.   Status: :checkhealth
 engine = "auto"
 
@@ -340,6 +352,17 @@ engine = "auto"
 # [engines.opencode]
 # model = "anthropic/claude-sonnet-4-5"
 
+# --- Templates -------------------------------------------------------------
+# Prompts you start agents with often. :new -t fix <task> starts an agent and
+# sends the prompt, {task} replaced by what you typed; :templates picks one.
+# Built in: fix, test, review, explain (one of yours with the same name
+# replaces it). engine, model, effort and worktree are optional.
+# [templates.migrate]
+# description = "a database migration, with a rollback"
+# prompt = "Write a migration that {task}. Include the rollback, and test both."
+# engine = "claude"
+# effort = "high"
+
 # --- Leader ----------------------------------------------------------------
 # What <leader> means in [keys]. Vim's default is "\\".
 leader = "<Space>"
@@ -355,6 +378,7 @@ timeoutlen = 1000      # ms to wait for the rest of a multi-key mapping
 # termguicolors = false  # for terminals without 24-bit color: use the nearest of 256
 # transparent = true    # use the terminal's background with any theme ("auto": the theme decides)
 whichkey = true          # after <leader>, show what each next key does (like which-key.nvim)
+notify = "auto"          # an agent finished while you looked elsewhere: "auto", "bell", "desktop", "off"
 
 # --- Colors (also live: :hi Group guifg=#... guibg=#...) -------------------
 # Applied on top of whichever theme is active. A value is a table, a vim

package/dist/diffview.js

@@ -7,7 +7,7 @@
  *
  * Both return the line indices of hunk headers so ]c / [c can jump.
  */
-import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "./tui.js";
 import { fileIcon } from "./icons.js";
 function lineGroup(line) {
     if (line.startsWith("+++") || line.startsWith("---"))

package/dist/engines.js

@@ -10,6 +10,7 @@ import { execFile } from "node:child_process";
 import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
+import { PI_INSTALL, piInstalled } from "./pi-sdk.js";
 export const ENGINE_IDS = ["pi", "claude", "codex", "opencode"];
 export const ENGINE_NAMES = {
     pi: "pi",
@@ -53,22 +54,25 @@ export function onPath(bin, env = process.env) {
 export function piConnected(env = process.env) {
     return detectPi(env).connected;
 }
+const CLI_IDS = ["claude", "codex", "opencode"];
 /**
- * The engine new agents use when none is given: pi if it has a key, else the
- * first signed-in CLI (Claude Code, Codex, OpenCode). Before the sign-in checks
- * finish, the first of those that is installed.
+ * The engine new agents use when none is given ("auto"): the first signed-in
+ * CLI (Claude Code, Codex, OpenCode), so your own login and settings are used;
+ * pi only when no CLI is ready and pi has a key. While the sign-in checks run,
+ * an installed CLI still wins over pi. With nothing ready, the first installed
+ * CLI, else pi (starting an agent then says how to connect one).
  */
 export function defaultEngine(engines, env = process.env) {
     if (engines) {
-        const ready = engines.find((e) => e.connected);
+        const cli = (ok) => CLI_IDS.map((id) => engines.find((e) => e.id === id)).find((e) => e && ok(e))?.id;
+        const ready = cli((e) => e.connected) ?? cli((e) => e.installed && Boolean(e.checking));
         if (ready)
-            return ready.id;
-        const installed = engines.find((e) => e.id !== "pi" && e.installed);
-        return installed?.id ?? "pi";
+            return ready;
+        if (engines.find((e) => e.id === "pi")?.connected)
+            return "pi";
+        return cli((e) => e.installed) ?? "pi";
     }
-    if (piConnected(env))
-        return "pi";
-    for (const id of ["claude", "codex", "opencode"])
+    for (const id of CLI_IDS)
         if (onPath(ENGINE_BINS[id], env))
             return id;
     return "pi";
@@ -88,7 +92,10 @@ function strip(s) {
 function firstVersion(s) {
     return /\d+\.\d+\.\d+[\w.-]*/.exec(s)?.[0];
 }
-function detectPi(env) {
+export function detectPi(env, installed = piInstalled()) {
+    if (!installed) {
+        return { id: "pi", name: ENGINE_NAMES.pi, installed: false, connected: false, detail: "not installed (light install)", install: PI_INSTALL };
+    }
     const keys = PI_KEYS.filter((k) => env[k]);
     let stored = false;
     try {

package/dist/float.js

@@ -3,7 +3,7 @@
  * optionally with selectable rows (`:dash`) and jump points (`]c` / `[c`
  * between diff hunks).
  */
-import { parseKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { parseKey, truncateToWidth, visibleWidth } from "./tui.js";
 import { RESET } from "./theme.js";
 export class TextFloat {
     painter;