@vigent/cli 0.0.0-stage → 0.2.0

package/dist/session.js

@@ -0,0 +1,460 @@
+import { flattenTree } from "./tree.js";
+import { diffStat } from "./worktree.js";
+export const STATE_GLYPH = {
+    running: "●",
+    waiting: "◐",
+    idle: "○",
+    paused: "‖",
+    error: "✗",
+};
+let nextId = 1;
+export class Session {
+    name;
+    model;
+    worktree;
+    id = nextId++;
+    /** what runs this agent */
+    engine = "pi";
+    /** reasoning effort / thinking level; undefined = the engine's default */
+    effort;
+    state = "idle";
+    items = [];
+    tokens = 0;
+    version = 0; // bumped on every change, used for render caching
+    listeners = new Set();
+    statTimer;
+    statRunning = false;
+    constructor(name, model, worktree) {
+        this.name = name;
+        this.model = model;
+        this.worktree = worktree;
+    }
+    /** Recount the worktree's changes (throttled; runs git in the background). */
+    refreshStat(delayMs = 300) {
+        const wt = this.worktree;
+        if (!wt?.path || this.statTimer)
+            return;
+        this.statTimer = setTimeout(async () => {
+            this.statTimer = undefined;
+            if (this.statRunning)
+                return this.refreshStat(delayMs);
+            this.statRunning = true;
+            try {
+                wt.stat = await diffStat(wt);
+                this.emit();
+            }
+            catch {
+                // the worktree may have been removed; keep the last numbers
+            }
+            finally {
+                this.statRunning = false;
+            }
+        }, delayMs);
+    }
+    /** Stop background work (stat refresh). Subclasses also stop the agent. */
+    dispose() {
+        if (this.statTimer)
+            clearTimeout(this.statTimer);
+        this.statTimer = undefined;
+    }
+    onChange(cb) {
+        this.listeners.add(cb);
+        return () => this.listeners.delete(cb);
+    }
+    emit() {
+        this.version++;
+        for (const cb of this.listeners)
+            cb();
+    }
+    pushUser(text) {
+        this.items.push({ kind: "user", text });
+        this.emit();
+    }
+    pushInfo(text) {
+        this.items.push({ kind: "info", text });
+        this.emit();
+    }
+    /** prompts waiting for the agent to finish its current run */
+    queue = [];
+    setState(s) {
+        if (this.state === "paused" && s === "idle")
+            return; // an aborted run settling while paused
+        this.state = s;
+        this.emit();
+        if ((s === "idle" || s === "waiting") && this.queue.length > 0) {
+            // next queued prompt, after the current event has been handled
+            setTimeout(() => this.drainQueue(), 0);
+        }
+    }
+    drainQueue() {
+        if (this.state === "running" || this.state === "paused" || this.queue.length === 0)
+            return;
+        const next = this.queue.shift();
+        this.emit();
+        this.send(next);
+    }
+    /**
+     * Send a prompt now, or queue it if the agent is busy (or paused).
+     * Returns how many prompts are waiting after this one, or 0 if it was sent.
+     */
+    submit(text) {
+        if (this.state === "running" || this.state === "paused") {
+            this.queue.push(text);
+            this.emit();
+            return this.queue.length;
+        }
+        this.send(text);
+        return 0;
+    }
+    /** Stop the current run and hold queued prompts until resume(). */
+    pause() {
+        if (this.state === "running")
+            this.abort();
+        this.state = "paused";
+        this.emit();
+    }
+    /** Continue: the next queued prompt, or ask the agent to pick up where it stopped. */
+    resume() {
+        if (this.state !== "paused")
+            return;
+        this.state = "idle";
+        this.emit();
+        if (this.queue.length > 0)
+            this.drainQueue();
+        else
+            this.send("Continue where you left off.");
+    }
+    toggleFolds() {
+        const tools = this.items.filter((i) => i.kind === "tool" && i.tool);
+        if (tools.length === 0)
+            return;
+        const anyFolded = tools.some((i) => i.tool.folded);
+        for (const i of tools)
+            i.tool.folded = !anyFolded;
+        this.emit();
+    }
+    /** Use this model from the next prompt on. */
+    setModel(model) {
+        if (model)
+            this.model = model;
+        this.emit();
+    }
+    /** Use this reasoning effort (thinking level) from the next prompt on. */
+    setEffort(effort) {
+        this.effort = effort && effort !== "default" ? effort : undefined;
+        this.emit();
+    }
+    /** The conversation tree (`:tree`), or undefined if this agent doesn't keep one. */
+    tree(_glyphs) {
+        return undefined;
+    }
+    /**
+     * Go back to an earlier point. Picking a prompt rewinds to just before it and
+     * returns its text to edit and resend; picking a reply continues from there.
+     */
+    async navigate(_id) {
+        throw new Error("this agent doesn't keep a conversation tree");
+    }
+}
+export class DemoSession extends Session {
+    timer;
+    script = [];
+    play(steps) {
+        this.script = [...steps];
+        this.next();
+    }
+    next() {
+        const step = this.script.shift();
+        if (!step)
+            return;
+        this.timer = setTimeout(() => this.run(step), step.delay);
+    }
+    run(step) {
+        switch (step.kind) {
+            case "state":
+                this.setState(step.state);
+                break;
+            case "info":
+                this.pushInfo(step.text ?? "");
+                break;
+            case "tool": {
+                this.items.push({
+                    kind: "tool",
+                    text: "",
+                    tool: { ...step.tool, folded: true },
+                });
+                this.tokens += Math.ceil((step.tool.output.length + step.tool.summary.length) / 4);
+                this.emit();
+                break;
+            }
+            case "agent": {
+                const words = (step.text ?? "").split(" ");
+                if (!step.streamMs) {
+                    this.items.push({ kind: "agent", text: step.text ?? "" });
+                    this.tokens += Math.ceil((step.text ?? "").length / 4);
+                    this.emit();
+                    break;
+                }
+                const item = { kind: "agent", text: "", streaming: true };
+                this.items.push(item);
+                let i = 0;
+                const tick = () => {
+                    if (i >= words.length) {
+                        item.streaming = false;
+                        this.emit();
+                        this.next();
+                        return;
+                    }
+                    item.text += (i > 0 ? " " : "") + words[i++];
+                    this.tokens += 1;
+                    this.emit();
+                    this.timer = setTimeout(tick, step.streamMs);
+                };
+                tick();
+                return; // next() is called when streaming finishes
+            }
+        }
+        this.next();
+    }
+    send(text) {
+        this.pushUser(text);
+        this.setState("running");
+        this.play([
+            { delay: 500, kind: "agent", streamMs: 60, text: "Got it — I'll take a look and get back to you. (demo mode: no model behind this session)" },
+            { delay: 200, kind: "state", state: "idle" },
+        ]);
+    }
+    abort() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.script = [];
+        this.setState("idle");
+    }
+}
+export class PiSession extends Session {
+    opts;
+    session;
+    ready;
+    cwd;
+    constructor(name, model, opts) {
+        super(name, model, opts.worktree);
+        this.opts = opts;
+        this.cwd = opts.cwd;
+        this.effort = opts.effort;
+        this.ready = this.init();
+    }
+    async init() {
+        const sdk = await import("@mariozechner/pi-coding-agent");
+        const sessionManager = this.opts.sessionDir
+            ? sdk.SessionManager.continueRecent(this.cwd, this.opts.sessionDir)
+            : sdk.SessionManager.inMemory();
+        const resuming = sessionManager.buildSessionContext().messages.length > 0;
+        let model = this.opts.modelObject;
+        if (!model && !resuming) {
+            model = await piModel(this.model); // undefined: let pi pick its default
+        }
+        // a resumed conversation keeps the model it was saved with, unless one is given
+        const { session } = await sdk.createAgentSession({
+            cwd: this.cwd,
+            ...(this.effort ? { thinkingLevel: this.effort } : {}),
+            ...(model ? { model: model } : {}),
+            sessionManager,
+            ...(this.opts.authStorage ? { authStorage: this.opts.authStorage } : {}),
+            ...(this.opts.agentDir ? { agentDir: this.opts.agentDir } : {}),
+        });
+        this.session = session;
+        if (resuming) {
+            const restored = itemsFromMessages(session.messages ?? []);
+            this.items.push(...restored.items);
+            this.tokens += restored.tokens;
+            this.pushInfo(`resumed: ${restored.items.filter((i) => i.kind === "user").length} earlier prompts`);
+            this.refreshStat(0);
+        }
+        session.subscribe((event) => this.onEvent(event));
+    }
+    onEvent(event) {
+        switch (event.type) {
+            case "agent_start":
+                this.setState("running");
+                break;
+            case "agent_end":
+                this.setState("idle");
+                this.refreshStat(0);
+                break;
+            case "message_start": {
+                if (event.message?.role === "assistant") {
+                    this.items.push({ kind: "agent", text: "", streaming: true });
+                    this.emit();
+                }
+                break;
+            }
+            case "message_update": {
+                const last = this.items[this.items.length - 1];
+                if (last?.kind === "agent" && event.message?.content) {
+                    last.text = extractText(event.message.content);
+                    this.emit();
+                }
+                break;
+            }
+            case "message_end": {
+                const last = this.items[this.items.length - 1];
+                if (last?.kind === "agent") {
+                    if (event.message?.content)
+                        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 (!last.text)
+                        this.items.pop(); // a turn that only called tools
+                    this.emit();
+                }
+                break;
+            }
+            case "tool_execution_start": {
+                this.items.push({
+                    kind: "tool",
+                    text: "",
+                    tool: { name: event.toolName, summary: summarizeArgs(event.args), output: "", folded: true },
+                });
+                this.emit();
+                break;
+            }
+            case "tool_execution_end": {
+                const item = [...this.items].reverse().find((i) => i.kind === "tool" && i.tool?.name === event.toolName);
+                if (item?.tool) {
+                    item.tool.output = extractText(event.result?.content ?? []) || JSON.stringify(event.result ?? "");
+                    this.emit();
+                }
+                this.refreshStat();
+                break;
+            }
+        }
+    }
+    async setModel(model) {
+        if (!model || model === "default")
+            return;
+        const m = await piModel(model);
+        if (!m)
+            throw new Error(`pi doesn't know the model '${model}' (provider/model, e.g. anthropic/claude-sonnet-4-5)`);
+        await this.ready;
+        await this.session.setModel(m);
+        this.model = model;
+        this.emit();
+    }
+    async setEffort(effort) {
+        await this.ready;
+        const level = !effort || effort === "default" ? "off" : effort;
+        this.session.setThinkingLevel(level);
+        this.effort = level === "off" ? undefined : level;
+        this.emit();
+    }
+    tree(glyphs) {
+        const sm = this.session?.sessionManager;
+        if (!sm)
+            return undefined;
+        return flattenTree(sm.getTree(), sm.getLeafId(), glyphs);
+    }
+    async navigate(id) {
+        await this.ready;
+        if (this.state === "running")
+            throw new Error(`'${this.name}' is running; wait for it or :pause it first`);
+        await this.session.agent?.waitForIdle?.();
+        const r = await this.session.navigateTree(id);
+        if (r.cancelled)
+            throw new Error("cancelled");
+        // the transcript shows the branch the agent is on now
+        this.items = itemsFromMessages(this.session.messages ?? []).items;
+        this.emit();
+        return { editorText: r.editorText };
+    }
+    send(text) {
+        this.pushUser(text);
+        this.setState("running");
+        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))
+            .catch((err) => {
+            this.pushInfo(`error: ${err?.message ?? err}`);
+            this.setState("error");
+        });
+    }
+    abort() {
+        this.session?.abort?.();
+        this.setState("idle");
+    }
+    dispose() {
+        super.dispose();
+        this.session?.dispose?.();
+    }
+}
+/** Rebuild the transcript from pi's saved messages: prompts, replies, and tool calls with their output. */
+export function itemsFromMessages(messages) {
+    const items = [];
+    const byCallId = new Map();
+    let tokens = 0;
+    for (const m of messages) {
+        if (m?.role === "user") {
+            const text = extractText(m.content);
+            if (text)
+                items.push({ kind: "user", text });
+        }
+        else if (m?.role === "assistant") {
+            const blocks = Array.isArray(m.content) ? m.content : [];
+            const text = extractText(blocks);
+            if (text)
+                items.push({ kind: "agent", text });
+            for (const b of blocks) {
+                if (b?.type !== "toolCall")
+                    continue;
+                const item = {
+                    kind: "tool",
+                    text: "",
+                    tool: { name: b.name, summary: summarizeArgs(b.arguments), output: "", folded: true },
+                };
+                items.push(item);
+                if (b.id)
+                    byCallId.set(b.id, item);
+            }
+            if (m.usage)
+                tokens += (m.usage.input ?? 0) + (m.usage.output ?? 0);
+        }
+        else if (m?.role === "toolResult") {
+            const item = byCallId.get(m.toolCallId);
+            if (item?.tool)
+                item.tool.output = extractText(m.content);
+        }
+    }
+    return { items, tokens };
+}
+function extractText(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .filter((b) => b?.type === "text" && typeof b.text === "string")
+        .map((b) => b.text)
+        .join("\n");
+}
+function summarizeArgs(args) {
+    if (!args)
+        return "";
+    if (typeof args === "string")
+        return args.slice(0, 80);
+    const v = args.command ?? args.path ?? args.file_path ?? args.filePath ?? JSON.stringify(args);
+    return String(v).slice(0, 80);
+}
+/** 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 slash = id.indexOf("/");
+    const [provider, modelId] = slash > 0 ? [id.slice(0, slash), id.slice(slash + 1)] : ["anthropic", id];
+    try {
+        return ai.getModel(provider, modelId) ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/settings.js

@@ -0,0 +1,174 @@
+/**
+ * `:settings`: every option in one float, changed in place.
+ *
+ *   j/k move · Enter or Space change · h/l step back or forward ·
+ *   w save to config.toml · q / Esc close
+ *
+ * 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 { keyFromInput } from "./keys.js";
+import { RESET } from "./theme.js";
+export class SettingsFloat {
+    painter;
+    icons;
+    items;
+    height;
+    onClose;
+    onSave;
+    requestRender;
+    index = 0;
+    scroll = 0;
+    capturing;
+    message = "";
+    constructor(painter, icons, items, height, onClose, onSave, requestRender) {
+        this.painter = painter;
+        this.icons = icons;
+        this.items = items;
+        this.height = height;
+        this.onClose = onClose;
+        this.onSave = onSave;
+        this.requestRender = requestRender;
+    }
+    /** rows: section headers and items, in order */
+    rows() {
+        const out = [];
+        let section = "";
+        this.items.forEach((item, i) => {
+            if (item.section !== section) {
+                section = item.section;
+                out.push({ header: section });
+            }
+            out.push({ item, i });
+        });
+        return out;
+    }
+    handleInput(data) {
+        const key = keyFromInput(data);
+        if (this.capturing) {
+            if (key === "<Esc>") {
+                this.capturing = undefined;
+                this.message = "cancelled";
+            }
+            else if (key === "<CR>") {
+                const keys = this.capturing;
+                this.capturing = undefined;
+                if (keys.length === 0)
+                    this.message = "no keys typed";
+                else
+                    this.message = this.items[this.index].bind?.(keys) ?? "";
+            }
+            else if (key === "<BS>") {
+                this.capturing.pop();
+            }
+            else if (key) {
+                this.capturing.push(key);
+            }
+            this.requestRender();
+            return;
+        }
+        const item = this.items[this.index];
+        switch (key) {
+            case "q":
+            case "<Esc>":
+            case "<C-c>":
+                this.onClose();
+                return;
+            case "j":
+            case "<Down>":
+            case "<Tab>":
+            case "<C-n>":
+                this.move(1);
+                break;
+            case "k":
+            case "<Up>":
+            case "<S-Tab>":
+            case "<C-p>":
+                this.move(-1);
+                break;
+            case "g":
+                this.index = 0;
+                break;
+            case "G":
+                this.index = this.items.length - 1;
+                break;
+            case "l":
+            case "<Right>":
+                item.change?.(1);
+                this.message = "";
+                break;
+            case "h":
+            case "<Left>":
+                item.change?.(-1);
+                this.message = "";
+                break;
+            case "<CR>":
+            case "<Space>":
+                this.message = "";
+                if (item.open) {
+                    item.open();
+                    return;
+                }
+                if (item.bind) {
+                    this.capturing = [];
+                    break;
+                }
+                item.change?.(1);
+                break;
+            case "w":
+                this.message = this.onSave();
+                break;
+        }
+        this.requestRender();
+    }
+    move(delta) {
+        this.index = (this.index + delta + this.items.length) % this.items.length;
+    }
+    invalidate() { }
+    render(width) {
+        const P = this.painter;
+        const I = this.icons;
+        const inner = Math.max(30, width) - 2;
+        const bg = P.attr("NormalFloat").bg;
+        const border = (s) => P.on("FloatBorder", bg) + s + RESET;
+        const row = (content, used, rowBg = bg) => border(I.v) + content + P.on("NormalFloat", rowBg) + " ".repeat(Math.max(0, inner - used)) + RESET + border(I.v);
+        const title = " Settings ";
+        const lines = [border(I.tl + I.h) + P.on("FloatTitle", bg) + title + RESET + border(I.h.repeat(Math.max(0, inner - 1 - visibleWidth(title))) + I.tr)];
+        const rows = this.rows();
+        const selectedRow = rows.findIndex((r) => "item" in r && r.i === this.index);
+        const room = Math.max(5, this.height() - 6);
+        if (selectedRow < this.scroll)
+            this.scroll = Math.max(0, selectedRow - 1);
+        if (selectedRow >= this.scroll + room)
+            this.scroll = selectedRow - room + 1;
+        for (const r of rows.slice(this.scroll, this.scroll + room)) {
+            if ("header" in r) {
+                lines.push(row(P.on("Title", bg) + ` ${r.header}` + RESET, r.header.length + 1));
+                continue;
+            }
+            const selected = r.i === this.index;
+            const rowBg = selected ? (P.attr("PmenuSel").bg ?? P.attr("Visual").bg) : bg;
+            const group = selected ? "PmenuSel" : "NormalFloat";
+            const value = selected && this.capturing
+                ? `${this.capturing.join("") || "…"}  (Enter keeps, Esc cancels)`
+                : r.item.value();
+            const labelW = Math.min(34, inner - 4);
+            const label = truncateToWidth(r.item.label, labelW, "…");
+            const valueText = truncateToWidth(value, Math.max(4, inner - labelW - 5), "…");
+            const arrows = r.item.change && !r.item.bind ? "‹ › " : "";
+            lines.push(row(P.on(group, rowBg) + `   ${label}${" ".repeat(Math.max(0, labelW - visibleWidth(label)))} ` + P.on(selected ? "PmenuSel" : "Special", rowBg) + valueText + P.on("Comment", rowBg) + (selected ? ` ${arrows}` : ""), 3 + labelW + 1 + visibleWidth(valueText) + (selected ? 1 + arrows.length : 0), rowBg));
+        }
+        while (lines.length < room + 1)
+            lines.push(row("", 0));
+        const item = this.items[this.index];
+        const hint = this.capturing
+            ? "type the new keys, then Enter · Backspace removes one · Esc cancels"
+            : this.message || item.hint || "";
+        lines.push(border(I.lt + I.h.repeat(inner) + I.rt));
+        lines.push(row(P.on(this.message && !this.capturing ? "ModeMsg" : "Comment", bg) + ` ${truncateToWidth(hint, inner - 2, "…")}` + RESET, Math.min(inner, hint.length + 1)));
+        const keys = " j/k move · Enter/Space change · h/l back/forward · w save to config.toml · q close ";
+        lines.push(border(I.bl) + P.on("Comment", bg) + truncateToWidth(keys, inner, "") + RESET + border(I.h.repeat(Math.max(0, inner - visibleWidth(truncateToWidth(keys, inner, "")))) + I.br));
+        return lines;
+    }
+}

package/dist/suggest.js

@@ -0,0 +1,31 @@
+/** "Did you mean ...?" for typos in action and theme names. */
+function distance(a, b) {
+    const dp = Array.from({ length: b.length + 1 }, (_, i) => i);
+    for (let i = 1; i <= a.length; i++) {
+        let prev = dp[0];
+        dp[0] = i;
+        for (let j = 1; j <= b.length; j++) {
+            const tmp = dp[j];
+            dp[j] = Math.min(dp[j] + 1, dp[j - 1] + 1, prev + (a[i - 1] === b[j - 1] ? 0 : 1));
+            prev = tmp;
+        }
+    }
+    return dp[b.length];
+}
+/** The closest candidate within a few edits, or undefined. */
+export function closest(name, candidates) {
+    let best;
+    let bestScore = Math.max(2, Math.floor(name.length / 3)) + 1;
+    for (const c of candidates) {
+        const d = distance(name.toLowerCase(), c.toLowerCase());
+        if (d < bestScore) {
+            best = c;
+            bestScore = d;
+        }
+    }
+    return best;
+}
+export function didYouMean(name, candidates) {
+    const c = closest(name, candidates);
+    return c ? ` (did you mean '${c}'?)` : "";
+}