@vigent/cli 0.0.0-stage → 0.2.1

package/dist/config.js

@@ -0,0 +1,406 @@
+/**
+ * ~/.config/vigent/config.toml
+ *
+ *   theme = "tokyonight"
+ *
+ *   [ui]
+ *   sidebar = true
+ *   sidebar_width = 30
+ *   number = true
+ *   tilde = true
+ *   icons = "unicode"        # or "ascii"
+ *
+ *   [highlights]             # applied on top of whichever theme is active
+ *   Normal = { bg = "NONE" } # transparent background
+ *   CursorLine = "guibg=#2a2f3a"
+ *   VigentSidebar = { link = "NormalFloat" }
+ */
+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 { isEngineId } from "./engines.js";
+import { WORKTREE_BACKENDS } from "./riftri.js";
+import { KEY_MODES } from "./keys.js";
+import { configDir, normalizeGroups } from "./theme.js";
+import { DEFAULT_WORKTREE } from "./worktree.js";
+export const DEFAULT_UI = {
+    sidebar: true,
+    sidebar_width: 30,
+    number: true,
+    tilde: true,
+    icons: "unicode",
+    timeoutlen: 1000,
+    // macOS Terminal.app can't show 24-bit color
+    termguicolors: process.env.TERM_PROGRAM !== "Apple_Terminal",
+    transparent: "auto",
+    whichkey: true,
+};
+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 warnings = [];
+    if (!fs.existsSync(file))
+        return { config, warnings };
+    let raw;
+    try {
+        raw = parseToml(fs.readFileSync(file, "utf8"));
+    }
+    catch (err) {
+        warnings.push(`${path.basename(file)}: ${err.message.split("\n")[0]}`);
+        return { config, warnings };
+    }
+    for (const [key, value] of Object.entries(raw)) {
+        switch (key) {
+            case "theme":
+            case "colorscheme":
+            case "model":
+            case "leader":
+            case "mapleader":
+                if (typeof value === "string") {
+                    const field = key === "colorscheme" ? "theme" : key === "mapleader" ? "leader" : key;
+                    config[field] = value;
+                }
+                else
+                    warnings.push(`config: '${key}' should be a string`);
+                break;
+            case "engine":
+                if (typeof value === "string" && (value === "auto" || isEngineId(value)))
+                    config.engine = value;
+                else
+                    warnings.push("config: 'engine' should be \"auto\", \"pi\", \"claude\", \"codex\" or \"opencode\"");
+                break;
+            case "engines":
+                if (!value || typeof value !== "object" || Array.isArray(value)) {
+                    warnings.push("config: [engines] should be a table");
+                    break;
+                }
+                for (const [id, opts] of Object.entries(value)) {
+                    if (!isEngineId(id)) {
+                        warnings.push(`config: unknown engine [engines.${id}] (pi, claude, codex or opencode)`);
+                        continue;
+                    }
+                    if (!opts || typeof opts !== "object" || Array.isArray(opts)) {
+                        warnings.push(`config: [engines.${id}] should be a table`);
+                        continue;
+                    }
+                    const e = {};
+                    for (const [k, v] of Object.entries(opts)) {
+                        if (k === "args" && Array.isArray(v) && v.every((a) => typeof a === "string"))
+                            e.args = v;
+                        else if (k === "model" && typeof v === "string")
+                            e.model = v;
+                        else if (k === "effort" && typeof v === "string" && EFFORTS[id].includes(v))
+                            e.effort = v;
+                        else if (k === "effort")
+                            warnings.push(`config [engines.${id}]: 'effort' should be one of ${EFFORTS[id].join(", ")}`);
+                        else
+                            warnings.push(`config [engines.${id}]: ${k === "args" ? "'args' should be a list of strings" : k === "model" ? "'model' should be a string" : `unknown option '${k}'`}`);
+                    }
+                    config.engines[id] = e;
+                }
+                break;
+            case "keys":
+                if (!value || typeof value !== "object" || Array.isArray(value)) {
+                    warnings.push("config: [keys] should be a table");
+                    break;
+                }
+                for (const [k, v] of Object.entries(value)) {
+                    if (KEY_MODES.includes(k) && v && typeof v === "object" && !Array.isArray(v)) {
+                        config.keys[k] = { ...config.keys[k], ...v };
+                    }
+                    else if (KEY_MODES.includes(k)) {
+                        warnings.push(`config: [keys.${k}] should be a table`);
+                    }
+                    else {
+                        // keys directly under [keys] are normal-mode mappings
+                        config.keys.normal = { ...config.keys.normal, [k]: v };
+                    }
+                }
+                break;
+            case "ui":
+                if (value && typeof value === "object") {
+                    for (const [opt, v] of Object.entries(value)) {
+                        const msg = setOption(config.ui, opt, v);
+                        if (msg)
+                            warnings.push(`config [ui]: ${msg}`);
+                    }
+                }
+                break;
+            case "highlights":
+                config.highlights = normalizeGroups(value);
+                break;
+            case "worktree":
+                if (!value || typeof value !== "object" || Array.isArray(value)) {
+                    warnings.push("config: [worktree] should be a table");
+                    break;
+                }
+                for (const [opt, v] of Object.entries(value)) {
+                    const msg = setWorktreeOption(config.worktree, opt, v);
+                    if (msg)
+                        warnings.push(`config [worktree]: ${msg}`);
+                }
+                break;
+            default:
+                warnings.push(`config: unknown key '${key}'`);
+        }
+    }
+    return { config, warnings };
+}
+function setWorktreeOption(wt, name, value) {
+    switch (name) {
+        case "enabled":
+            if (typeof value !== "boolean")
+                return "'enabled' should be true or false";
+            wt.enabled = value;
+            return;
+        case "dir":
+        case "base":
+            if (typeof value !== "string")
+                return `'${name}' should be a string`;
+            if (name === "dir" && !value.trim())
+                return "'dir' can't be empty";
+            wt[name] = value;
+            return;
+        case "backend":
+            if (typeof value !== "string" || !WORKTREE_BACKENDS.includes(value))
+                return "'backend' should be \"auto\", \"riftri\" or \"git\"";
+            wt.backend = value;
+            return;
+        case "branch":
+            if (typeof value !== "string")
+                return "'branch' should be a string";
+            if (!value.includes("{name}"))
+                return "'branch' should contain {name}, e.g. \"{type}/{name}\" or \"agent/{name}\"";
+            wt.branch = value;
+            return;
+        default:
+            return `unknown option '${name}'`;
+    }
+}
+const ALIASES = {
+    sidebar: "sidebar",
+    sb: "sidebar",
+    sidebar_width: "sidebar_width",
+    sidebarwidth: "sidebar_width",
+    sbw: "sidebar_width",
+    number: "number",
+    nu: "number",
+    tilde: "tilde",
+    icons: "icons",
+    timeoutlen: "timeoutlen",
+    tm: "timeoutlen",
+    termguicolors: "termguicolors",
+    tgc: "termguicolors",
+    transparent: "transparent",
+    transp: "transparent",
+    whichkey: "whichkey",
+    wk: "whichkey",
+};
+/** Set one option from a config value. Returns an error message, or undefined on success. */
+export function setOption(ui, name, value) {
+    const key = ALIASES[name];
+    if (!key)
+        return `unknown option '${name}'`;
+    switch (key) {
+        case "sidebar":
+        case "number":
+        case "tilde":
+        case "termguicolors":
+        case "whichkey":
+            if (typeof value !== "boolean")
+                return `'${name}' should be true or false`;
+            ui[key] = value;
+            return;
+        case "sidebar_width": {
+            const n = Number(value);
+            if (!Number.isInteger(n) || n < 16 || n > 80)
+                return `'${name}' should be a number from 16 to 80`;
+            ui.sidebar_width = n;
+            return;
+        }
+        case "icons":
+            if (value !== "unicode" && value !== "ascii")
+                return `'${name}' should be "unicode" or "ascii"`;
+            ui.icons = value;
+            return;
+        case "transparent":
+            if (value === true || value === false || value === "auto")
+                ui.transparent = value;
+            else if (value === "true" || value === "false")
+                ui.transparent = value === "true";
+            else
+                return `'${name}' should be true, false or "auto" (follow the theme)`;
+            return;
+        case "timeoutlen": {
+            const n = Number(value);
+            if (!Number.isInteger(n) || n < 0 || n > 10000)
+                return `'${name}' should be milliseconds from 0 to 10000`;
+            ui.timeoutlen = n;
+            return;
+        }
+    }
+}
+/**
+ * Apply a vim-style `:set` argument: `number`, `nonumber`, `number!`,
+ * `invnumber`, `sidebar_width=40`, `number?`. Returns the message to show.
+ */
+export function applySetCommand(ui, arg, 
+/** what's on screen now, for toggling an option that follows the theme */
+now = {}) {
+    const show = (k) => {
+        const v = ui[k];
+        return typeof v === "boolean" ? (v ? `  ${k}` : `no${k}`) : `  ${k}=${v}`;
+    };
+    if (!arg.trim()) {
+        return { message: Object.keys(ui).map(show).join("  ") };
+    }
+    const parts = arg.trim().split(/\s+/);
+    const shown = [];
+    for (const part of parts) {
+        let m;
+        if ((m = /^([\w]+)\?$/.exec(part))) {
+            const key = ALIASES[m[1]];
+            if (!key)
+                return { message: `E518: Unknown option: ${m[1]}`, error: true };
+            shown.push(show(key));
+            continue;
+        }
+        if ((m = /^([\w]+)=(.*)$/.exec(part))) {
+            const err = setOption(ui, m[1], m[2]);
+            if (err)
+                return { message: `E518: ${err}`, error: true };
+            continue;
+        }
+        if ((m = /^([\w]+)!$/.exec(part)) || (m = /^inv([\w]+)$/.exec(part))) {
+            const key = ALIASES[m[1]];
+            if (key === "transparent") {
+                // following the theme: flip what's on screen
+                ui.transparent = !(ui.transparent === "auto" ? Boolean(now.transparent) : ui.transparent);
+                continue;
+            }
+            if (!key || typeof ui[key] !== "boolean")
+                return { message: `E518: Unknown option: ${part}`, error: true };
+            ui[key] = !ui[key];
+            continue;
+        }
+        if ((m = /^([\w]+)&$/.exec(part))) {
+            // vim's :set option& : back to the default
+            const key = ALIASES[m[1]];
+            if (!key)
+                return { message: `E518: Unknown option: ${m[1]}`, error: true };
+            ui[key] = DEFAULT_UI[key];
+            continue;
+        }
+        const m2 = /^no([\w]+)$/.exec(part);
+        const off = Boolean(m2 && ALIASES[m2[1]]);
+        const key = ALIASES[off ? m2[1] : part];
+        if (!key)
+            return { message: `E518: Unknown option: ${part}`, error: true };
+        if (typeof ui[key] !== "boolean" && key !== "transparent") {
+            shown.push(show(key));
+            continue;
+        }
+        ui[key] = !off;
+    }
+    return { message: shown.join("  ") };
+}
+export const CONFIG_TEMPLATE = `# vigent config: ~/.config/vigent/config.toml
+# Reference: https://github.com/farming-labs/vigent/blob/main/docs/config.md
+# Check it any time with:  vigent config check
+
+# --- Theme -----------------------------------------------------------------
+# Built-in: default, lazyvim (transparent), tokyonight, tokyonight-moon, gruvbox,
+# catppuccin, catppuccin-latte, nord, rose-pine, kanagawa. Or any theme in ~/.config/vigent/themes, e.g. one made
+# with  vigent theme import  (your nvim/vim colorscheme) or  vigent theme new.
+theme = "default"
+
+# Model used for new pi agents.
+# model = "claude-sonnet-4-5"
+
+# --- 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.
+# Per agent: :new fix the race --engine codex.   Status: :checkhealth
+engine = "auto"
+
+# Each CLI runs as it is, with its own login. Extra arguments and a model:
+# [engines.claude]
+# args = ["--permission-mode", "acceptEdits"]   # the default
+# model = "sonnet"
+# [engines.codex]
+# args = ["-c", 'sandbox_mode="workspace-write"']  # the default
+# [engines.opencode]
+# model = "anthropic/claude-sonnet-4-5"
+
+# --- Leader ----------------------------------------------------------------
+# What <leader> means in [keys]. Vim's default is "\\".
+leader = "<Space>"
+
+# --- Options (also live: :set nonumber, :set sidebar_width=40, ...) --------
+[ui]
+sidebar = true
+sidebar_width = 30
+number = true          # session numbers in the sidebar
+tilde = true           # ~ on empty sidebar rows
+icons = "unicode"      # "ascii" for fonts without box-drawing characters
+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)
+
+# --- Colors (also live: :hi Group guifg=#... guibg=#...) -------------------
+# Applied on top of whichever theme is active. A value is a table, a vim
+# :hi string, or the name of a group to link to.
+[highlights]
+# Normal = { bg = "NONE" }                 # use the terminal's background
+# CursorLine = "guibg=#2a2f3a"
+# Comment = "gui=NONE"                      # no italic comments
+# VigentModeNormal = { fg = "#1a1b26", bg = "#7aa2f7", bold = true }
+
+# --- Worktrees --------------------------------------------------------------
+# Each agent gets its own git worktree and branch, so agents never touch your
+# checkout or each other. ":new fix flaky checkout test" creates the branch
+# fix/flaky-checkout-test in ../<repo>-worktrees/fix-flaky-checkout-test.
+[worktree]
+enabled = true
+dir = "../{repo}-worktrees"     # relative to the repo root
+branch = "{type}/{name}"        # {type} = feat, fix, docs, refactor, ... from the agent's name
+# base = "main"                 # default: the branch you have checked out
+# With riftri installed (https://riftri.dev), unchanged files in agent
+# worktrees share copy-on-write storage, so each new agent costs almost no
+# disk. "auto" uses riftri when it can and git otherwise; "git" turns it off.
+backend = "auto"
+
+# --- Keys (also live: :nmap, :imap, :cmap, :unmap; list them with :help) ---
+# Left side: vim notation, e.g. j  gg  <C-d>  <S-Tab>  <M-x>  <CR>  <leader>t
+# Right side:
+#   "session.next"                       an action (all of them: :help)
+#   ":colorscheme nord<CR>"              run an ex command
+#   ":new "                              open the command line with that text
+#   "gg"                                 other keys, with their built-in meaning
+#   ["fold.open_all", "scroll.bottom"]   several, in order
+#   false                                unbind a built-in key
+
+[keys.normal]
+"<leader>n" = ":new "              # type a name, then Enter
+"<leader>x" = ":kill<CR>"
+"<leader>t" = "theme.picker"
+"<leader>h" = "app.help"
+"<Tab>" = "session.next"
+"<S-Tab>" = "session.prev"
+# "J" = "scroll.half_down"
+# "K" = "scroll.half_up"
+# "q" = false                       # stop q from showing the quit hint
+
+[keys.insert]
+# "jk" = "<Esc>"                    # leave INSERT by typing jk quickly
+# "<C-s>" = "edit.submit"
+
+[keys.command]
+# "<C-p>" = "edit.clear"
+`;

package/dist/demo.js

@@ -0,0 +1,81 @@
+/** Scripted demo content so the UI can be explored without API keys. */
+import { DemoSession } from "./session.js";
+import { branchName } from "./worktree.js";
+export function createDemoSessions() {
+    const auth = new DemoSession("auth-refactor", "claude-sonnet-5-5", {
+        branch: branchName("auth-refactor"),
+        stat: { files: 2, added: 41, removed: 18 },
+    });
+    auth.pushUser("Refactor the session middleware to use the new token store.");
+    auth.play([
+        { delay: 300, kind: "state", state: "running" },
+        {
+            delay: 400,
+            kind: "agent",
+            streamMs: 90,
+            text: "I'll start by reading the current middleware to understand how sessions are validated today.",
+        },
+        {
+            delay: 500,
+            kind: "tool",
+            tool: {
+                name: "read",
+                summary: "src/middleware/auth.ts",
+                output: "import { verify } from '../lib/jwt';\n\nexport async function authMiddleware(req, res, next) {\n  const token = req.headers.authorization?.split(' ')[1];\n  if (!token) return res.status(401).end();\n  // legacy: validates against the jwt secret directly\n  const claims = verify(token, process.env.JWT_SECRET);\n  req.user = claims.sub;\n  next();\n}",
+            },
+        },
+        {
+            delay: 900,
+            kind: "tool",
+            tool: {
+                name: "edit",
+                summary: "src/middleware/auth.ts (+41 −18)",
+                output: "- const claims = verify(token, process.env.JWT_SECRET);\n- req.user = claims.sub;\n+ const session = await tokenStore.resolve(token);\n+ if (!session) return res.status(401).end();\n+ req.user = session.userId;",
+            },
+        },
+        {
+            delay: 800,
+            kind: "tool",
+            tool: { name: "bash", summary: "npm test -- auth", output: "PASS test/middleware/auth.test.ts\n  ✓ rejects missing token (3 ms)\n  ✓ resolves session from TokenStore (5 ms)\n  ✓ rejects revoked tokens (2 ms)\n\nTests: 14 passed, 14 total" },
+        },
+        {
+            delay: 700,
+            kind: "agent",
+            streamMs: 80,
+            text: [
+                "Done. The middleware now resolves tokens through **TokenStore** instead of verifying JWTs inline:",
+                "- revoked tokens are rejected with a `401`",
+                "- all 14 tests pass",
+                "```ts",
+                "const session = await tokenStore.resolve(token);",
+                "if (!session) return res.status(401).end();",
+                "```",
+                "Want me to update the docs too?",
+            ].join("\n"),
+        },
+        { delay: 300, kind: "state", state: "waiting" },
+    ]);
+    const flaky = new DemoSession("fix-flaky-test", "claude-haiku-5-5", {
+        branch: branchName("fix-flaky-test"),
+        stat: { files: 1, added: 6, removed: 2 },
+    });
+    flaky.pushUser("The checkout e2e test fails ~1 in 5 runs. Find the race and fix it.");
+    flaky.play([
+        { delay: 1200, kind: "state", state: "running" },
+        { delay: 600, kind: "agent", streamMs: 110, text: "Reproducing first — running the suite 10 times to catch the failure." },
+        {
+            delay: 1500,
+            kind: "tool",
+            tool: { name: "bash", summary: "for i in $(seq 10); do npm run e2e -- checkout; done", output: "run 1..6: pass\nrun 7: FAIL expected cart badge '3', got '2'\nrun 8..10: pass" },
+        },
+        { delay: 2500, kind: "agent", streamMs: 120, text: "Caught it: the badge assertion runs before the cart mutation settles. The test clicks 'add' and asserts immediately instead of awaiting the network idle. Fixing with a proper waitFor on the cart response." },
+        { delay: 200, kind: "state", state: "waiting" },
+    ]);
+    const docs = new DemoSession("docs-pass", "claude-haiku-5-5");
+    docs.pushUser("Sweep the README for stale CLI flags.");
+    docs.play([
+        { delay: 500, kind: "agent", text: "Swept README.md and docs/cli.md: fixed 3 stale flags (--watch → --dev, removed --legacy-peer, documented --json). Committed as docs: refresh CLI flags." },
+        { delay: 100, kind: "state", state: "idle" },
+    ]);
+    return [auth, flaky, docs];
+}

package/dist/diffview.js

@@ -0,0 +1,94 @@
+/**
+ * :diff layouts for the floating diff window.
+ *
+ * unified: git's own output, colored.
+ * split:   side by side, old on the left and new on the right, with line
+ *          numbers; removed and added lines are paired up row by row.
+ *
+ * Both return the line indices of hunk headers so ]c / [c can jump.
+ */
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+function lineGroup(line) {
+    if (line.startsWith("+++") || line.startsWith("---"))
+        return "Title";
+    if (line.startsWith("+"))
+        return "Added";
+    if (line.startsWith("-"))
+        return "Removed";
+    if (line.startsWith("@@"))
+        return "Special";
+    if (/^(diff --git|index |new file|deleted file|similarity|rename )/.test(line))
+        return "Comment";
+    return "NormalFloat";
+}
+export function unifiedView(text) {
+    const raw = text.replace(/\n$/, "").split("\n");
+    return {
+        lines: raw.map((l) => [[lineGroup(l), l]]),
+        jumps: raw.map((l, i) => (l.startsWith("@@") ? i : -1)).filter((i) => i >= 0),
+    };
+}
+function cell(no, text, width, group) {
+    if (text === undefined)
+        return [["NonText", " ".repeat(width)]];
+    const num = no === undefined ? "    " : String(no).padStart(4);
+    const body = truncateToWidth(text.replace(/\t/g, "  "), Math.max(0, width - 5), "…");
+    return [
+        ["LineNr", `${num} `],
+        [group, body + " ".repeat(Math.max(0, width - 5 - visibleWidth(body)))],
+    ];
+}
+/** Side-by-side layout for a window `width` columns wide (inside its border). */
+export function splitView(text, width) {
+    const col = Math.max(12, Math.floor((width - 3) / 2));
+    const lines = [];
+    const jumps = [];
+    let oldNo = 0;
+    let newNo = 0;
+    let dels = [];
+    let adds = [];
+    const row = (l, r, lg = "NormalFloat", rg = "NormalFloat") => lines.push([...cell(l?.no, l?.text, col, lg), ["NonText", " │ "], ...cell(r?.no, r?.text, col, rg)]);
+    const flush = () => {
+        for (let i = 0; i < Math.max(dels.length, adds.length); i++)
+            row(dels[i], adds[i], "Removed", "Added");
+        dels = [];
+        adds = [];
+    };
+    for (const line of text.replace(/\n$/, "").split("\n")) {
+        if (line.startsWith("diff --git")) {
+            flush();
+            if (lines.length > 0)
+                lines.push([]);
+            continue;
+        }
+        const file = /^\+\+\+ (?:b\/)?(.*)$/.exec(line);
+        if (file) {
+            lines.push([["Title", file[1] === "/dev/null" ? "(deleted file)" : file[1]]]);
+            continue;
+        }
+        if (/^(---|index |new file|deleted file|similarity|rename |\\ No newline)/.test(line))
+            continue;
+        const hunk = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@(.*)$/.exec(line);
+        if (hunk) {
+            flush();
+            oldNo = Number(hunk[1]);
+            newNo = Number(hunk[2]);
+            jumps.push(lines.length);
+            lines.push([["Special", line]]);
+            continue;
+        }
+        if (line.startsWith("-")) {
+            dels.push({ no: oldNo++, text: line.slice(1) });
+        }
+        else if (line.startsWith("+")) {
+            adds.push({ no: newNo++, text: line.slice(1) });
+        }
+        else {
+            flush();
+            const t = line.startsWith(" ") ? line.slice(1) : line;
+            row({ no: oldNo++, text: t }, { no: newNo++, text: t });
+        }
+    }
+    flush();
+    return { lines, jumps };
+}