@vigent/cli 0.0.0-stage → 0.2.1

package/dist/palette.js

@@ -0,0 +1,83 @@
+/**
+ * Build a full theme from a small color palette.
+ *
+ * Only bg, fg and the six accent colors are required; everything else is
+ * derived. This is the easiest way to write a custom theme:
+ *
+ *   [palette]
+ *   bg = "#0b0e14"
+ *   fg = "#bfbdb6"
+ *   red = "#f07178"  ...
+ */
+import { isLight, mix } from "./color.js";
+export const PALETTE_KEYS = [
+    "bg", "fg", "red", "yellow", "green", "cyan", "blue", "magenta",
+    "bg_dark", "bg_alt", "selection", "muted", "subtle", "orange", "accent",
+];
+export function fromPalette(name, p) {
+    const light = isLight(p.bg);
+    const bgDark = p.bg_dark ?? mix(p.bg, "#000000", light ? 0.05 : 0.22);
+    const bgAlt = p.bg_alt ?? mix(p.bg, p.fg, 0.08);
+    const selection = p.selection ?? mix(p.bg, p.blue, 0.28);
+    const muted = p.muted ?? mix(p.bg, p.fg, 0.45);
+    const subtle = p.subtle ?? mix(p.bg, p.fg, 0.25);
+    const orange = p.orange ?? p.yellow;
+    const accent = p.accent ?? p.yellow;
+    const badge = (bg) => ({ fg: p.bg, bg, bold: true });
+    return {
+        name,
+        background: light ? "light" : "dark",
+        // kept so `vigent theme new --from <this>` can start from the exact colors
+        palette: { ...p, bg_dark: bgDark, bg_alt: bgAlt, selection, muted, subtle, orange, accent },
+        groups: {
+            Normal: { fg: p.fg, bg: p.bg },
+            NormalFloat: { fg: p.fg, bg: bgDark },
+            FloatBorder: { fg: subtle, bg: bgDark },
+            FloatTitle: { fg: p.blue, bg: bgDark, bold: true },
+            WinSeparator: { fg: subtle },
+            StatusLine: { fg: p.fg, bg: bgAlt },
+            StatusLineNC: { fg: muted, bg: bgDark },
+            WinBar: { fg: p.fg, bold: true },
+            CursorLine: { bg: bgAlt },
+            CursorLineNr: { fg: accent, bold: true },
+            LineNr: { fg: subtle },
+            Visual: { bg: selection },
+            Comment: { fg: muted, italic: true },
+            NonText: { fg: subtle },
+            Title: { fg: p.blue, bold: true },
+            Directory: { fg: p.blue },
+            Identifier: { fg: p.magenta },
+            Function: { fg: p.blue },
+            String: { fg: p.green },
+            Constant: { fg: orange },
+            Keyword: { fg: p.magenta },
+            Statement: { fg: p.magenta },
+            Type: { fg: p.yellow },
+            Special: { fg: p.cyan },
+            Search: { fg: p.bg, bg: p.yellow },
+            CurSearch: { fg: p.bg, bg: orange },
+            DiffAdd: { bg: mix(p.bg, p.green, 0.2) },
+            DiffDelete: { bg: mix(p.bg, p.red, 0.2) },
+            DiffChange: { bg: mix(p.bg, p.blue, 0.15) },
+            Added: { fg: p.green },
+            Removed: { fg: p.red },
+            Changed: { fg: p.blue },
+            ErrorMsg: { fg: p.red },
+            WarningMsg: { fg: p.yellow },
+            ModeMsg: { fg: p.fg, bold: true },
+            MoreMsg: { fg: p.green },
+            Pmenu: { fg: p.fg, bg: bgAlt },
+            PmenuSel: { bg: selection, bold: true },
+            VigentSidebar: { fg: p.fg, bg: bgDark },
+            VigentIndent: { fg: subtle },
+            VigentModeNormal: badge(p.blue),
+            VigentModeInsert: badge(p.green),
+            VigentModeVisual: badge(p.magenta),
+            VigentModeCommand: badge(p.yellow),
+            VigentUser: { fg: p.blue, bold: true },
+            VigentTool: { fg: p.cyan },
+            VigentToolOutput: { fg: muted },
+            VigentSpinner: { fg: orange },
+        },
+    };
+}

package/dist/picker.js

@@ -0,0 +1,301 @@
+/**
+ * Floating colorscheme picker (`:colorscheme` with no argument).
+ *
+ * Type to filter, arrows / Ctrl-n / Ctrl-p / Tab to move (each move previews
+ * the theme live), Enter to keep it, Esc to go back to the previous theme.
+ */
+import { fuzzyFilter, parseKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { RESET, sgr } from "./theme.js";
+export const PICKER_ICONS = {
+    unicode: { tl: "╭", tr: "╮", bl: "╰", br: "╯", h: "─", v: "│", lt: "├", rt: "┤", current: "●", prompt: "❯" },
+    ascii: { tl: "+", tr: "+", bl: "+", br: "+", h: "-", v: "|", lt: "+", rt: "+", current: "*", prompt: ">" },
+};
+const VISIBLE = 14;
+export class ThemePicker {
+    painter;
+    themes;
+    current;
+    icons;
+    onPreview;
+    onDone;
+    requestRender;
+    look;
+    query = "";
+    index = 0;
+    scroll = 0;
+    constructor(painter, themes, current, icons, onPreview, onDone, requestRender, look = () => undefined) {
+        this.painter = painter;
+        this.themes = themes;
+        this.current = current;
+        this.icons = icons;
+        this.onPreview = onPreview;
+        this.onDone = onDone;
+        this.requestRender = requestRender;
+        this.look = look;
+        this.index = Math.max(0, themes.indexOf(current));
+        this.scroll = Math.max(0, this.index - VISIBLE + 1);
+    }
+    filtered() {
+        return this.query ? fuzzyFilter(this.themes, this.query, (t) => t) : this.themes;
+    }
+    move(delta) {
+        const items = this.filtered();
+        if (items.length === 0)
+            return;
+        this.index = (this.index + delta + items.length) % items.length;
+        if (this.index < this.scroll)
+            this.scroll = this.index;
+        if (this.index >= this.scroll + VISIBLE)
+            this.scroll = this.index - VISIBLE + 1;
+        this.onPreview(items[this.index]);
+    }
+    handleInput(data) {
+        const key = parseKey(data) ?? "";
+        switch (key) {
+            case "escape":
+            case "ctrl+c":
+                this.onDone(null);
+                return;
+            case "enter":
+            case "return": {
+                const items = this.filtered();
+                this.onDone(items[this.index] ?? null);
+                return;
+            }
+            case "down":
+            case "tab":
+            case "ctrl+n":
+            case "ctrl+j":
+                this.move(1);
+                break;
+            case "up":
+            case "shift+tab":
+            case "ctrl+p":
+            case "ctrl+k":
+                this.move(-1);
+                break;
+            case "backspace":
+                this.query = this.query.slice(0, -1);
+                this.resetSelection();
+                break;
+            case "ctrl+u":
+                this.query = "";
+                this.resetSelection();
+                break;
+            default:
+                if (data.length >= 1 && !data.startsWith("\x1b") && data >= " ") {
+                    this.query += data;
+                    this.resetSelection();
+                }
+        }
+        this.requestRender();
+    }
+    resetSelection() {
+        this.index = 0;
+        this.scroll = 0;
+        const first = this.filtered()[0];
+        if (first)
+            this.onPreview(first);
+    }
+    lookCache = new Map();
+    looks(name) {
+        if (!this.lookCache.has(name))
+            this.lookCache.set(name, this.look(name));
+        return this.lookCache.get(name);
+    }
+    invalidate() { }
+    render(width) {
+        const P = this.painter;
+        const I = this.icons;
+        const w = Math.max(20, width);
+        const inner = w - 2;
+        const bg = P.attr("NormalFloat").bg;
+        const border = (s) => P.on("FloatBorder", bg) + s + RESET;
+        const row = (content, plainWidth, rowBg = bg) => border(I.v) +
+            content +
+            P.on("NormalFloat", rowBg) +
+            " ".repeat(Math.max(0, inner - plainWidth)) +
+            RESET +
+            border(I.v);
+        const items = this.filtered();
+        const title = " Colorschemes ";
+        const count = ` ${items.length === 0 ? 0 : this.index + 1}/${items.length} `;
+        const top = 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 lines = [top];
+        const prompt = `${I.prompt} ${this.query}`;
+        lines.push(row(P.on("Title", bg) + ` ${I.prompt} ` + RESET + P.on("NormalFloat", bg) + this.query + P.on("PmenuSel", undefined) + " " + RESET, visibleWidth(prompt) + 2));
+        lines.push(border(I.lt + I.h.repeat(inner) + I.rt));
+        const shown = items.slice(this.scroll, this.scroll + VISIBLE);
+        for (let i = 0; i < VISIBLE; i++) {
+            const name = shown[i];
+            if (name === undefined) {
+                lines.push(row("", 0));
+                continue;
+            }
+            const selected = this.scroll + i === this.index;
+            const rowBg = selected ? (P.attr("PmenuSel").bg ?? P.attr("Visual").bg) : bg;
+            const marker = name === this.current ? `${I.current} ` : "  ";
+            const group = selected ? "PmenuSel" : "NormalFloat";
+            const look = this.looks(name);
+            // name, then a strip of the theme's own colors, then its tags
+            const swatchW = look ? look.colors.length * 2 + 1 : 0;
+            const tags = look?.tags.join(" ") ?? "";
+            const nameW = Math.max(8, Math.min(24, inner - 2 - swatchW - (tags ? tags.length + 1 : 0)));
+            const text = truncateToWidth(`${marker}${name}`, nameW, "…");
+            let content = P.on(group, rowBg) + ` ${text}${" ".repeat(Math.max(0, nameW - visibleWidth(text)))} `;
+            let used = nameW + 2;
+            if (look && inner - used >= swatchW) {
+                for (const c of look.colors)
+                    content += sgr({ bg: c }, P.colorMode) + "  ";
+                content += RESET + P.on(group, rowBg) + " ";
+                used += swatchW;
+                if (tags && inner - used >= tags.length) {
+                    content += P.on("Comment", rowBg) + tags;
+                    used += tags.length;
+                }
+            }
+            lines.push(row(content + RESET, used, rowBg));
+        }
+        if (items.length === 0)
+            lines[3] = row(P.on("Comment", bg) + "  no match" + RESET, 10);
+        lines.push(border(I.bl + I.h.repeat(Math.max(0, inner - visibleWidth(count) - 1))) +
+            P.on("Comment", bg) +
+            count +
+            RESET +
+            border(I.h + I.br));
+        return lines;
+    }
+}
+/**
+ * A filterable list (`:model`, `:effort`). Type to filter, ↑/↓ (Ctrl-n/p,
+ * Tab) to move, Enter picks. With `custom`, Enter on text that matches
+ * nothing picks the text itself (a model the list doesn't know).
+ */
+export class ChoicePicker {
+    painter;
+    icons;
+    title;
+    current;
+    custom;
+    onDone;
+    requestRender;
+    query = "";
+    index = 0;
+    scroll = 0;
+    items = [];
+    loading = true;
+    constructor(painter, icons, title, items, current, custom, onDone, requestRender) {
+        this.painter = painter;
+        this.icons = icons;
+        this.title = title;
+        this.current = current;
+        this.custom = custom;
+        this.onDone = onDone;
+        this.requestRender = requestRender;
+        Promise.resolve(items)
+            .then((list) => {
+            this.items = list;
+            this.loading = false;
+            this.index = Math.max(0, list.findIndex((c) => c.value === current));
+            this.scroll = Math.max(0, this.index - VISIBLE + 1);
+            this.requestRender();
+        })
+            .catch(() => {
+            this.loading = false;
+            this.requestRender();
+        });
+    }
+    filtered() {
+        return this.query ? fuzzyFilter(this.items, this.query, (c) => `${c.value} ${c.note ?? ""}`) : this.items;
+    }
+    handleInput(data) {
+        const key = parseKey(data) ?? "";
+        const items = this.filtered();
+        switch (key) {
+            case "escape":
+            case "ctrl+c":
+                this.onDone(null);
+                return;
+            case "enter":
+            case "return": {
+                const picked = items[this.index]?.value ?? (this.custom && this.query.trim() ? this.query.trim() : undefined);
+                if (picked !== undefined)
+                    this.onDone(picked);
+                return;
+            }
+            case "down":
+            case "tab":
+            case "ctrl+n":
+            case "ctrl+j":
+                if (items.length)
+                    this.index = (this.index + 1) % items.length;
+                break;
+            case "up":
+            case "shift+tab":
+            case "ctrl+p":
+            case "ctrl+k":
+                if (items.length)
+                    this.index = (this.index - 1 + items.length) % items.length;
+                break;
+            case "backspace":
+                this.query = this.query.slice(0, -1);
+                this.index = 0;
+                break;
+            case "ctrl+u":
+                this.query = "";
+                this.index = 0;
+                break;
+            default:
+                if (data.length >= 1 && !data.startsWith("\x1b") && data >= " ") {
+                    this.query += data;
+                    this.index = 0;
+                }
+        }
+        if (this.index < this.scroll)
+            this.scroll = this.index;
+        if (this.index >= this.scroll + VISIBLE)
+            this.scroll = this.index - VISIBLE + 1;
+        this.requestRender();
+    }
+    invalidate() { }
+    render(width) {
+        const P = this.painter;
+        const I = this.icons;
+        const inner = Math.max(20, 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 items = this.filtered();
+        const title = ` ${this.title} `;
+        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)];
+        lines.push(row(P.on("Title", bg) + ` ${I.prompt} ` + RESET + P.on("NormalFloat", bg) + this.query + P.on("PmenuSel", undefined) + " " + RESET, visibleWidth(this.query) + 4));
+        lines.push(border(I.lt + I.h.repeat(inner) + I.rt));
+        const shown = items.slice(this.scroll, this.scroll + VISIBLE);
+        for (let i = 0; i < VISIBLE; i++) {
+            const c = shown[i];
+            if (!c) {
+                let text = "";
+                if (i === 0 && this.loading)
+                    text = "  loading…";
+                else if (i === 0 && items.length === 0)
+                    text = this.custom && this.query.trim() ? `  Enter uses '${this.query.trim()}'` : "  no match";
+                lines.push(row(P.on("Comment", bg) + truncateToWidth(text, inner, "…") + RESET, Math.min(inner, visibleWidth(text))));
+                continue;
+            }
+            const selected = this.scroll + i === this.index;
+            const rowBg = selected ? (P.attr("PmenuSel").bg ?? P.attr("Visual").bg) : bg;
+            const group = selected ? "PmenuSel" : "NormalFloat";
+            const marker = c.value === this.current ? `${I.current} ` : "  ";
+            const name = truncateToWidth(`${marker}${c.value}`, Math.max(10, inner - 4), "…");
+            const note = c.note ? truncateToWidth(`  ${c.note}`, Math.max(0, inner - 2 - visibleWidth(name)), "…") : "";
+            lines.push(row(P.on(group, rowBg) + ` ${name}` + P.on("Comment", rowBg) + note + RESET, 1 + visibleWidth(name) + visibleWidth(note), rowBg));
+        }
+        const count = ` ${items.length ? this.index + 1 : 0}/${items.length}${this.custom ? " · type any name" : ""} `;
+        lines.push(border(I.bl + I.h.repeat(Math.max(0, inner - visibleWidth(count) - 1))) + P.on("Comment", bg) + count + RESET + border(I.h + I.br));
+        return lines;
+    }
+}

package/dist/review.js

@@ -0,0 +1,158 @@
+/**
+ * Getting an agent's work out of its worktree: `:merge` and `:pr`.
+ *
+ * Both first commit whatever the agent left uncommitted, with a conventional
+ * message built from the branch (fix/flaky-checkout-test -> "fix: flaky
+ * checkout test").
+ *
+ * :merge squash-merges the branch into the base branch in your checkout (one
+ * commit, like GitHub's squash merge). It refuses unless your checkout is on
+ * that base branch with no uncommitted changes, and a conflict is rolled back
+ * so your checkout is left exactly as it was.
+ *
+ * :pr pushes the branch and opens a pull request with `gh`, or prints the
+ * compare URL when gh isn't available.
+ */
+import { execFileSync, spawnSync } from "node:child_process";
+function git(args, cwd) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function gitError(err) {
+    const e = err;
+    const text = String(e.stderr || e.stdout || e.message || err).trim();
+    return text.replace(/^(fatal|error): /gm, "").split("\n")[0];
+}
+/** "fix/flaky-checkout-test" -> "fix: flaky checkout test"; "agent/add-search" -> "add search". */
+export function commitMessage(branch) {
+    const parts = branch.split("/");
+    const name = (parts.pop() ?? branch).replace(/-\d+$/, "").replace(/-/g, " ");
+    const type = parts.pop();
+    const conventional = ["feat", "fix", "docs", "refactor", "test", "chore", "perf", "ci", "build", "style"];
+    return type && conventional.includes(type) ? `${type}: ${name}` : name;
+}
+/** Commit everything the agent left uncommitted. Returns the new commit, or undefined if there was nothing. */
+export function commitPending(wt, message = commitMessage(wt.branch)) {
+    if (!wt.path)
+        throw new Error("no worktree");
+    if (git(["status", "--porcelain"], wt.path) === "")
+        return undefined;
+    git(["add", "-A"], wt.path);
+    try {
+        git(["commit", "-q", "-m", message], wt.path);
+    }
+    catch (err) {
+        throw new Error(`commit failed: ${gitError(err)}`);
+    }
+    return git(["rev-parse", "--short", "HEAD"], wt.path);
+}
+/**
+ * Squash-merge (default) or merge the agent's branch into its base branch,
+ * in your checkout at `root`.
+ */
+export function mergeWorktree(root, wt, opts = {}) {
+    const squash = opts.squash ?? true;
+    if (!wt.path)
+        return { ok: false, message: "this agent has no worktree" };
+    const base = wt.base;
+    if (!base)
+        return { ok: false, message: "unknown base branch for this worktree" };
+    const current = git(["branch", "--show-current"], root);
+    if (current !== base) {
+        return { ok: false, message: `your checkout is on '${current || "a detached HEAD"}'; switch it to '${base}' to merge` };
+    }
+    if (git(["status", "--porcelain", "--untracked-files=no"], root) !== "") {
+        return { ok: false, message: `your checkout has uncommitted changes; commit or stash them, then :merge again` };
+    }
+    let pending;
+    try {
+        pending = commitPending(wt);
+    }
+    catch (err) {
+        return { ok: false, message: err.message };
+    }
+    if (git(["rev-list", "--count", `${base}..${wt.branch}`], root) === "0") {
+        return { ok: false, message: `nothing to merge: ${wt.branch} has no changes on top of ${base}` };
+    }
+    const message = commitMessage(wt.branch);
+    if (squash) {
+        try {
+            git(["merge", "--squash", wt.branch], root);
+        }
+        catch (err) {
+            const reason = gitError(err);
+            git(["reset", "-q", "--merge"], root); // undo the half-applied squash
+            return { ok: false, message: `merge conflict, nothing changed: ${reason}` };
+        }
+        if (git(["diff", "--cached", "--name-only"], root) === "") {
+            git(["reset", "-q", "--merge"], root);
+            return { ok: false, message: `nothing to merge: ${wt.branch} is already in ${base}` };
+        }
+        const log = git(["log", "--reverse", "--format=- %s", `${base}..${wt.branch}`], root);
+        git(["commit", "-q", "-m", message, "-m", log], root);
+    }
+    else {
+        try {
+            git(["merge", "--no-ff", "-q", "-m", `Merge branch '${wt.branch}'`, wt.branch], root);
+        }
+        catch (err) {
+            const reason = gitError(err);
+            try {
+                git(["merge", "--abort"], root);
+            }
+            catch {
+                // nothing to abort
+            }
+            return { ok: false, message: `merge conflict, nothing changed: ${reason}` };
+        }
+    }
+    const commit = git(["rev-parse", "--short", "HEAD"], root);
+    const how = squash ? "squash-merged" : "merged";
+    return {
+        ok: true,
+        commit,
+        message: `${how} ${wt.branch} into ${base} as ${commit}${pending ? " (committed the agent's pending changes first)" : ""}`,
+    };
+}
+/** https://github.com/owner/repo from an https or ssh remote URL, or undefined for other hosts. */
+export function githubWebUrl(remote) {
+    const m = /github\.com[:/]([^/]+)\/([^/]+?)(?:\.git)?\/?$/.exec(remote.trim());
+    return m ? `https://github.com/${m[1]}/${m[2]}` : undefined;
+}
+/** Push the agent's branch and open a pull request (with gh when it's available). */
+export function openPullRequest(root, wt, opts = {}) {
+    const remote = opts.remote ?? "origin";
+    if (!wt.path)
+        return { ok: false, message: "this agent has no worktree" };
+    let remoteUrl;
+    try {
+        remoteUrl = git(["remote", "get-url", remote], root);
+    }
+    catch {
+        return { ok: false, message: `no '${remote}' remote to push to` };
+    }
+    try {
+        commitPending(wt);
+    }
+    catch (err) {
+        return { ok: false, message: err.message };
+    }
+    try {
+        git(["push", "-q", "-u", remote, wt.branch], wt.path);
+    }
+    catch (err) {
+        return { ok: false, message: `git push failed: ${gitError(err)}` };
+    }
+    const base = wt.base ?? "main";
+    if (opts.useGh !== false) {
+        const gh = spawnSync("gh", ["pr", "create", "--base", base, "--head", wt.branch, "--title", commitMessage(wt.branch), "--fill"], { cwd: wt.path, encoding: "utf8", timeout: 60_000 });
+        const url = /https:\/\/\S+\/pull\/\d+/.exec(`${gh.stdout ?? ""}\n${gh.stderr ?? ""}`)?.[0];
+        if (url)
+            return { ok: true, url, message: `pull request: ${url}` };
+    }
+    const web = githubWebUrl(remoteUrl);
+    if (web) {
+        const url = `${web}/compare/${base}...${wt.branch}?expand=1`;
+        return { ok: true, url, message: `pushed ${wt.branch}; open the pull request at ${url}` };
+    }
+    return { ok: true, message: `pushed ${wt.branch} to ${remote}` };
+}