@vigent/cli 0.0.0-stage → 0.2.1

package/dist/version.js

@@ -0,0 +1,45 @@
+/** Which vigent is running: the package version, plus the git commit when it runs from a clone. */
+import { execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import { fileURLToPath } from "node:url";
+const root = fileURLToPath(new URL("..", import.meta.url));
+export const VERSION = (() => {
+    try {
+        return JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8")).version ?? "0";
+    }
+    catch {
+        return "0";
+    }
+})();
+/** The short commit vigent was built from, when it runs from a git clone (npm link); else undefined. */
+export const COMMIT = (() => {
+    if (!fs.existsSync(new URL("../.git", import.meta.url)))
+        return undefined;
+    try {
+        return execFileSync("git", ["rev-parse", "--short", "HEAD"], { cwd: root, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+})();
+/** "0.2.0 (ed9418d)" from a clone, "0.2.0" from npm. */
+export const VERSION_TEXT = COMMIT ? `${VERSION} (${COMMIT})` : VERSION;
+/**
+ * In a clone: is the compiled code older than the source? (`git pull` without
+ * `npm install` / `npm run build` leaves dist/ behind, and the new themes and
+ * commands seem missing.) Returns the warning to show, or undefined.
+ */
+export function staleBuild(dir = root) {
+    const src = `${dir}/src`;
+    const built = `${dir}/dist/cli.js`;
+    if (!fs.existsSync(`${dir}/.git`) || !fs.existsSync(src) || !fs.existsSync(built))
+        return undefined;
+    try {
+        const builtAt = fs.statSync(built).mtimeMs;
+        const newer = fs.readdirSync(src).some((f) => f.endsWith(".ts") && fs.statSync(`${src}/${f}`).mtimeMs > builtAt + 1000);
+        return newer ? `this vigent was built before its source last changed: run  npm install  (or  npm run build ) in ${dir.replace(/\/$/, "")}` : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/vimcolors.js

@@ -0,0 +1,206 @@
+/**
+ * Vim `:highlight` syntax support.
+ *
+ * - parseHighlightCommand(): the arguments of a single `:hi` command
+ *   (used by the in-app `:hi` command and by the file parser)
+ * - parseVimColorscheme(): a static reader for `.vim` colorscheme files, so
+ *   classic vim themes can be imported without vim or nvim installed
+ */
+import { resolveVimColor } from "./color.js";
+/** Split on whitespace, keeping 'quoted' and "quoted" values together. */
+export function tokenize(s) {
+    const out = [];
+    const re = /(\S+?=(?:'[^']*'|"[^"]*")|\S+)/g;
+    let m;
+    while ((m = re.exec(s)))
+        out.push(m[1]);
+    return out;
+}
+const ATTR_WORDS = {
+    bold: "bold",
+    italic: "italic",
+    underline: "underline",
+    undercurl: "underline",
+    underdouble: "underline",
+    underdotted: "underline",
+    underdashed: "underline",
+    reverse: "reverse",
+    inverse: "reverse",
+    standout: "reverse",
+};
+function applyAttrList(list, attr) {
+    for (const word of list.toLowerCase().split(",")) {
+        if (word === "none") {
+            attr.bold = attr.italic = attr.underline = attr.reverse = false;
+            continue;
+        }
+        const key = ATTR_WORDS[word];
+        if (key)
+            attr[key] = true;
+    }
+}
+/**
+ * Convert raw vim values to an Attr, preferring GUI colors over cterm ones.
+ * With keepOff, attributes turned off by `gui=NONE` stay as `false` so they
+ * can switch off a theme's bold/italic when merged as an override.
+ */
+export function rawToAttr(raw, keepOff = false) {
+    const attr = {};
+    const fg = raw.guifg ? resolveVimColor(raw.guifg) : undefined;
+    const bg = raw.guibg ? resolveVimColor(raw.guibg) : undefined;
+    attr.fg = fg ?? (raw.ctermfg ? resolveVimColor(raw.ctermfg, true) : undefined);
+    attr.bg = bg ?? (raw.ctermbg ? resolveVimColor(raw.ctermbg, true) : undefined);
+    const attrs = raw.gui ?? raw.cterm;
+    if (attrs)
+        applyAttrList(attrs, attr);
+    for (const k of Object.keys(attr)) {
+        if (attr[k] === undefined || (attr[k] === false && !keepOff))
+            delete attr[k];
+    }
+    return attr;
+}
+/**
+ * Parse the arguments of a `:highlight` command (everything after `hi`).
+ * Accepts vim keys (guifg, guibg, gui, ctermfg, ctermbg, cterm) plus the
+ * nvim_set_hl-style shorthands fg=, bg=, and bare words like `bold`.
+ */
+export function parseHighlightCommand(args) {
+    let tokens = tokenize(args.trim());
+    if (tokens[0] === "!")
+        tokens = tokens.slice(1);
+    if (tokens[0] === "default" || tokens[0] === "def")
+        tokens = tokens.slice(1);
+    if (tokens.length === 0)
+        return undefined;
+    if (tokens[0] === "clear")
+        return { kind: "clear", group: tokens[1] };
+    if (tokens[0] === "link") {
+        if (tokens.length < 3)
+            return undefined;
+        return { kind: "link", from: tokens[1], to: tokens[2] };
+    }
+    const group = tokens[0];
+    if (tokens.length === 1)
+        return { kind: "show", group };
+    const raw = {};
+    const extra = {};
+    for (const tok of tokens.slice(1)) {
+        const eq = tok.indexOf("=");
+        if (eq < 0) {
+            applyAttrList(tok, extra);
+            continue;
+        }
+        const key = tok.slice(0, eq).toLowerCase();
+        const value = tok.slice(eq + 1).replace(/^["']|["']$/g, "");
+        switch (key) {
+            case "guifg":
+            case "fg":
+                raw.guifg = value;
+                break;
+            case "guibg":
+            case "bg":
+                raw.guibg = value;
+                break;
+            case "gui":
+                raw.gui = value;
+                break;
+            case "ctermfg":
+                raw.ctermfg = value;
+                break;
+            case "ctermbg":
+                raw.ctermbg = value;
+                break;
+            case "cterm":
+                raw.cterm = value;
+                break;
+            // guisp, term, font, blend, start, stop: not used by a terminal UI
+        }
+    }
+    return { kind: "set", group, attr: { ...rawToAttr(raw, true), ...extra }, raw };
+}
+/** Evaluate an `if` condition. Only `&background` checks are understood; anything else is assumed true. */
+function evalCondition(cond, background) {
+    const m = /&(?:background|bg)\s*(==|!=|is|isnot)[#?]?\s*['"](dark|light)['"]/.exec(cond);
+    if (!m)
+        return true;
+    const equal = m[2] === background;
+    return m[1] === "==" || m[1] === "is" ? equal : !equal;
+}
+/** Statically read a `.vim` colorscheme file. Lines built at runtime (exe, functions) are skipped. */
+export function parseVimColorscheme(text, background) {
+    // join line continuations ("\" at the start of the next line)
+    const lines = text.replace(/\r/g, "").replace(/\n\s*\\/g, " ").split("\n");
+    const setBg = /^\s*set\s+(?:background|bg)=(dark|light)/m.exec(text);
+    const bg = background ?? (setBg ? setBg[1] : "dark");
+    const raw = {};
+    const links = {};
+    const stack = [];
+    let name;
+    const active = () => (stack.length === 0 ? true : stack[stack.length - 1].active);
+    for (const original of lines) {
+        const line = original.trim();
+        if (line === "" || line.startsWith('"'))
+            continue;
+        let m;
+        if ((m = /^if\s+(.*)$/.exec(line))) {
+            const parentActive = active();
+            const ok = parentActive && evalCondition(m[1], bg);
+            stack.push({ active: ok, taken: ok, parentActive });
+            continue;
+        }
+        if ((m = /^elseif\s+(.*)$/.exec(line))) {
+            const f = stack[stack.length - 1];
+            if (!f)
+                continue;
+            const ok = f.parentActive && !f.taken && evalCondition(m[1], bg);
+            f.active = ok;
+            f.taken ||= ok;
+            continue;
+        }
+        if (/^else\b/.test(line)) {
+            const f = stack[stack.length - 1];
+            if (!f)
+                continue;
+            f.active = f.parentActive && !f.taken;
+            f.taken = true;
+            continue;
+        }
+        if (/^endif\b/.test(line)) {
+            stack.pop();
+            continue;
+        }
+        if (!active())
+            continue;
+        if (/^fini(sh)?\b/.test(line))
+            break;
+        if ((m = /^let\s+g:colors_name\s*=\s*['"]([^'"]+)['"]/.exec(line))) {
+            name = m[1];
+            continue;
+        }
+        if ((m = /^hi(?:g|gh|ghl|ghli|ghlig|ghligh|ghlight)?(!?)\s+(.*)$/.exec(line))) {
+            const cmd = parseHighlightCommand(m[2].replace(/\s+"[^"]*$/, ""));
+            if (!cmd)
+                continue;
+            if (cmd.kind === "link") {
+                links[cmd.from] = cmd.to;
+            }
+            else if (cmd.kind === "set") {
+                raw[cmd.group] = { ...raw[cmd.group], ...cmd.raw };
+                // a group with its own colors stops following a link, as in vim
+                if (cmd.raw.guifg || cmd.raw.guibg || cmd.raw.ctermfg || cmd.raw.ctermbg)
+                    delete links[cmd.group];
+            }
+        }
+    }
+    const groups = {};
+    for (const [group, r] of Object.entries(raw)) {
+        const attr = rawToAttr(r);
+        if (Object.keys(attr).length > 0)
+            groups[group] = attr;
+    }
+    for (const [from, to] of Object.entries(links)) {
+        if (!groups[from])
+            groups[from] = { link: to };
+    }
+    return { name, background: bg, groups };
+}

package/dist/worktree.js

@@ -0,0 +1,357 @@
+/**
+ * One git worktree per agent.
+ *
+ * `:new fix flaky checkout test` creates the branch `fix/flaky-checkout-test`
+ * from the branch you're on, checks it out in its own worktree next to the
+ * repo (../<repo>-worktrees/fix-flaky-checkout-test), and runs the agent
+ * there. Agents never touch your checkout or each other's files.
+ *
+ * With riftri installed (https://riftri.dev, see riftri.ts) the worktree's
+ * unchanged files share copy-on-write storage with the other agents', so a
+ * new agent costs almost no disk. It's still a real git worktree.
+ *
+ * Removing is always the safe path: `git worktree remove` (or `riftri
+ * worktree remove`) refuses when there are uncommitted changes, and
+ * `git branch -d` keeps branches that aren't merged, unless you ask for --force.
+ */
+import { execFile, execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { promisify } from "node:util";
+import { describeFailure, riftriAdd, riftriBinary, riftriGc, riftriOwnership, riftriRemove, RIFTRI_INSTALL } from "./riftri.js";
+const execFileAsync = promisify(execFile);
+export const DEFAULT_WORKTREE = {
+    enabled: true,
+    dir: "../{repo}-worktrees",
+    branch: "{type}/{name}",
+    backend: "auto",
+};
+function git(args, cwd) {
+    return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+}
+function gitOk(args, cwd) {
+    try {
+        git(args, cwd);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Readable message from a failed git command. */
+function gitError(err) {
+    const e = err;
+    const text = (e.stderr ? String(e.stderr) : e.message ?? String(err)).trim();
+    return text.replace(/^(fatal|error): /gm, "").split("\n")[0];
+}
+/** The repository's top-level folder, or undefined outside a git repo. */
+export function repoRoot(cwd) {
+    try {
+        return git(["rev-parse", "--show-toplevel"], cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+export function currentBranch(cwd) {
+    try {
+        return git(["symbolic-ref", "--short", "-q", "HEAD"], cwd);
+    }
+    catch {
+        return git(["rev-parse", "--short", "HEAD"], cwd);
+    }
+}
+// ---------------------------------------------------------------------------
+// Branch names
+// ---------------------------------------------------------------------------
+/** Words that name the kind of change, mapped to the conventional branch type. */
+const TYPES = {
+    feat: "feat",
+    feature: "feat",
+    fix: "fix",
+    bugfix: "fix",
+    hotfix: "fix",
+    bug: "fix",
+    docs: "docs",
+    doc: "docs",
+    refactor: "refactor",
+    test: "test",
+    tests: "test",
+    chore: "chore",
+    perf: "perf",
+    ci: "ci",
+    build: "build",
+    style: "style",
+};
+/** lowercase, ascii, hyphen-separated, at most `max` characters (cut on a word boundary). */
+export function slugify(text, max = 48) {
+    const slug = text
+        .normalize("NFKD")
+        .replace(/[̀-ͯ]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    if (slug.length <= max)
+        return slug;
+    const cut = slug.slice(0, max + 1);
+    const boundary = cut.lastIndexOf("-");
+    return (boundary > 8 ? cut.slice(0, boundary) : slug.slice(0, max)).replace(/-+$/, "");
+}
+/**
+ * A conventional branch name for an agent:
+ *   "fix flaky checkout test" -> fix/flaky-checkout-test
+ *   "auth-refactor"           -> refactor/auth
+ *   "docs: readme flags"      -> docs/readme-flags
+ *   "add dark mode"           -> feat/add-dark-mode
+ *   "release/v2-notes"        -> release/v2-notes   (a name with "/" is used as written)
+ */
+export function branchName(agentName, template = DEFAULT_WORKTREE.branch) {
+    if (agentName.includes("/")) {
+        const parts = agentName.split("/").map((p) => slugify(p)).filter(Boolean);
+        if (parts.length > 0)
+            return parts.join("/");
+    }
+    const words = slugify(agentName, 200).split("-").filter(Boolean);
+    let type = "feat";
+    if (words.length > 1 && TYPES[words[0]]) {
+        type = TYPES[words.shift()];
+    }
+    else if (words.length > 1 && TYPES[words[words.length - 1]]) {
+        type = TYPES[words.pop()];
+    }
+    const name = slugify(words.join("-")) || "agent";
+    return template.replace(/\{type\}/g, type).replace(/\{name\}/g, name);
+}
+function isValidBranch(name, cwd) {
+    return gitOk(["check-ref-format", "--branch", name], cwd);
+}
+function branchExists(name, cwd) {
+    return gitOk(["show-ref", "--verify", "--quiet", `refs/heads/${name}`], cwd);
+}
+export function worktreesDir(root, config = DEFAULT_WORKTREE) {
+    const dir = config.dir.replace(/\{repo\}/g, path.basename(root));
+    return path.resolve(root, dir);
+}
+// ---------------------------------------------------------------------------
+// Create / remove / list
+// ---------------------------------------------------------------------------
+export function createWorktree(root, agentName, config = DEFAULT_WORKTREE) {
+    const base = config.base || currentBranch(root);
+    const wanted = branchName(agentName, config.branch);
+    if (!isValidBranch(wanted, root))
+        throw new Error(`'${wanted}' is not a valid branch name (check [worktree] branch)`);
+    const dir = worktreesDir(root, config);
+    let branch = wanted;
+    let folder = path.join(dir, wanted.replace(/\//g, "-"));
+    for (let n = 2; branchExists(branch, root) || fs.existsSync(folder); n++) {
+        branch = `${wanted}-${n}`;
+        folder = path.join(dir, branch.replace(/\//g, "-"));
+    }
+    fs.mkdirSync(dir, { recursive: true });
+    excludeIfInside(root, dir);
+    const info = { branch, path: folder, base, stat: { files: 0, added: 0, removed: 0 } };
+    const backend = config.backend ?? "auto";
+    if (backend !== "git") {
+        if (!riftriBinary()) {
+            if (backend === "riftri")
+                throw new Error(`[worktree] backend is "riftri", but riftri isn't installed: ${RIFTRI_INSTALL}`);
+        }
+        else {
+            const r = riftriAdd(root, folder, branch, base);
+            if (r.ok)
+                return { ...info, riftri: r.report?.backend ?? "riftri" };
+            // riftri declined (unsupported volume, checkout or environment) and changed nothing: git is safe
+            if (!r.declined || backend === "riftri")
+                throw new Error(`riftri worktree add failed: ${describeFailure(r)}`);
+            info.riftriSkipped = r.message;
+        }
+    }
+    try {
+        git(["worktree", "add", "-b", branch, folder, base], root);
+    }
+    catch (err) {
+        throw new Error(`git worktree add failed: ${gitError(err)}`);
+    }
+    return info;
+}
+/** A worktrees folder inside the repo goes in .git/info/exclude (local, never committed) so `git status` stays clean. */
+function excludeIfInside(root, dir) {
+    const rel = path.relative(root, dir);
+    if (!rel || rel.startsWith("..") || path.isAbsolute(rel))
+        return;
+    const file = path.resolve(root, git(["rev-parse", "--git-path", "info/exclude"], root));
+    const entry = `/${rel.split(path.sep).join("/")}/`;
+    const current = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    if (current.split("\n").includes(entry))
+        return;
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.appendFileSync(file, `${current && !current.endsWith("\n") ? "\n" : ""}${entry}\n`);
+}
+/**
+ * Remove a worktree, then delete its branch if it's merged. Without `force`,
+ * git refuses to remove a worktree with uncommitted changes and keeps an
+ * unmerged branch, so no work is lost by accident.
+ */
+export function removeWorktree(root, wt, force = false) {
+    const dirtyMessage = `${wt.path} has uncommitted changes; use force to remove it anyway`;
+    const owner = riftriOwnership(root, wt.path);
+    if (owner.error)
+        return { removed: false, branchDeleted: false, message: `riftri: ${owner.error}` };
+    if (owner.managed) {
+        // riftri's removal is journaled; a forced one snapshots the view first
+        const r = riftriRemove(root, wt.path, force);
+        if (!r.ok) {
+            const dirty = /has changes|uncommitted|dirty/i.test(r.message);
+            return { removed: false, branchDeleted: false, message: dirty ? dirtyMessage : `riftri worktree remove failed: ${describeFailure(r)}` };
+        }
+        riftriGc(root); // free the shared base once no agent uses it
+    }
+    else {
+        try {
+            git(["worktree", "remove", ...(force ? ["--force"] : []), wt.path], root);
+        }
+        catch (err) {
+            const reason = gitError(err);
+            const dirty = /modified or untracked|contains modified/.test(reason);
+            return { removed: false, branchDeleted: false, message: dirty ? dirtyMessage : reason };
+        }
+    }
+    if (!wt.branch)
+        return { removed: true, branchDeleted: false, message: `removed ${wt.path}` };
+    try {
+        const merged = force || isSquashMerged(root, wt.branch, wt.base);
+        git(["branch", merged ? "-D" : "-d", wt.branch], root);
+        return { removed: true, branchDeleted: true, message: `removed ${wt.path} and branch ${wt.branch}` };
+    }
+    catch {
+        return {
+            removed: true,
+            branchDeleted: false,
+            message: `removed ${wt.path}; kept branch ${wt.branch} (it has commits that aren't merged)`,
+        };
+    }
+}
+/**
+ * A squash merge makes a new commit, so git doesn't see the branch as merged.
+ * Treat it as merged when every file it changed has the same content on base.
+ */
+export function isSquashMerged(root, branch, base) {
+    if (!base)
+        return false;
+    try {
+        const fork = git(["merge-base", base, branch], root);
+        const files = git(["diff", "--name-only", fork, branch], root).split("\n").filter(Boolean);
+        if (files.length === 0)
+            return false;
+        return gitOk(["diff", "--quiet", base, branch, "--", ...files], root);
+    }
+    catch {
+        return false;
+    }
+}
+/** Worktrees vigent manages (the ones inside the worktrees folder). */
+export function listWorktrees(root, config = DEFAULT_WORKTREE) {
+    const dir = worktreesDir(root, config);
+    const out = [];
+    let current = {};
+    const flush = () => {
+        if (current.path && (current.path === dir || current.path.startsWith(dir + path.sep))) {
+            out.push({ path: current.path, branch: current.branch, head: current.head ?? "" });
+        }
+        current = {};
+    };
+    for (const line of git(["worktree", "list", "--porcelain"], root).split("\n")) {
+        if (line.startsWith("worktree ")) {
+            flush();
+            current.path = line.slice(9);
+        }
+        else if (line.startsWith("HEAD "))
+            current.head = line.slice(5, 12);
+        else if (line.startsWith("branch "))
+            current.branch = line.slice(7).replace(/^refs\/heads\//, "");
+    }
+    flush();
+    return out;
+}
+/** Find a managed worktree by branch, folder name, or path. */
+export function findWorktree(root, query, config = DEFAULT_WORKTREE) {
+    const all = listWorktrees(root, config);
+    const abs = path.resolve(query);
+    return (all.find((w) => w.branch === query) ??
+        all.find((w) => path.basename(w.path) === query) ??
+        all.find((w) => w.path === abs) ??
+        all.find((w) => w.branch === branchName(query, config.branch)));
+}
+// ---------------------------------------------------------------------------
+// Changes
+// ---------------------------------------------------------------------------
+async function gitAsync(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, { cwd, maxBuffer: 32 * 1024 * 1024 });
+        return stdout;
+    }
+    catch (err) {
+        // `git diff --no-index` exits 1 when files differ; its stdout is still the diff
+        const e = err;
+        if (e.code === 1 && typeof e.stdout === "string")
+            return e.stdout;
+        throw err;
+    }
+}
+/** The commit the worktree branched from, so later commits on the base don't show as changes. */
+async function forkPoint(wt) {
+    if (!wt.path)
+        throw new Error("no worktree");
+    if (!wt.base)
+        return "HEAD";
+    try {
+        return (await gitAsync(["merge-base", wt.base, "HEAD"], wt.path)).trim();
+    }
+    catch {
+        return wt.base;
+    }
+}
+async function untrackedFiles(cwd) {
+    const out = await gitAsync(["ls-files", "--others", "--exclude-standard", "-z"], cwd);
+    return out.split("\0").filter(Boolean);
+}
+/** Everything the agent changed since the fork point: commits, uncommitted edits, and new files. */
+export async function diffStat(wt) {
+    if (!wt.path)
+        return wt.stat ?? { files: 0, added: 0, removed: 0 };
+    const from = await forkPoint(wt);
+    const stat = { files: 0, added: 0, removed: 0 };
+    for (const line of (await gitAsync(["diff", "--numstat", from], wt.path)).split("\n")) {
+        const m = /^(\d+|-)\t(\d+|-)\t/.exec(line);
+        if (!m)
+            continue;
+        stat.files++;
+        stat.added += m[1] === "-" ? 0 : Number(m[1]);
+        stat.removed += m[2] === "-" ? 0 : Number(m[2]);
+    }
+    for (const file of await untrackedFiles(wt.path)) {
+        stat.files++;
+        try {
+            const buf = fs.readFileSync(path.join(wt.path, file));
+            const text = buf.includes(0) ? "" : buf.toString("utf8"); // skip binary files
+            if (text)
+                stat.added += text.split("\n").length - (text.endsWith("\n") ? 1 : 0);
+        }
+        catch {
+            // unreadable: count the file, not its lines
+        }
+    }
+    return stat;
+}
+/** Unified diff of everything the agent changed, new files included. */
+export async function diffText(wt, maxLines = 4000) {
+    if (!wt.path)
+        return "";
+    const from = await forkPoint(wt);
+    let text = await gitAsync(["diff", "--no-color", from], wt.path);
+    for (const file of await untrackedFiles(wt.path)) {
+        text += await gitAsync(["diff", "--no-color", "--no-index", "--", "/dev/null", file], wt.path);
+    }
+    const lines = text.split("\n");
+    return lines.length > maxLines ? `${lines.slice(0, maxLines).join("\n")}\n… ${lines.length - maxLines} more lines` : text;
+}

package/package.json

@@ -1,6 +1,66 @@
 {
   "name": "@vigent/cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.1",
+  "description": "A vim-style terminal app for running coding agents side by side, each in its own git worktree. Built on pi.",
+  "keywords": [
+    "vim",
+    "neovim",
+    "tui",
+    "terminal",
+    "coding-agent",
+    "ai",
+    "agents",
+    "git-worktree",
+    "pi",
+    "llm",
+    "cli"
+  ],
+  "homepage": "https://github.com/farming-labs/vigent#readme",
+  "bugs": {
+    "url": "https://github.com/farming-labs/vigent/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/farming-labs/vigent.git"
+  },
+  "license": "MIT",
+  "author": "KinfeMichael Tariku",
+  "type": "module",
+  "bin": {
+    "vigent": "./dist/cli.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "clean": "node -e \"require('fs').rmSync('dist', { recursive: true, force: true })\"",
+    "build": "tsc",
+    "prepare": "npm run build",
+    "start": "node dist/cli.js",
+    "demo": "node dist/cli.js --demo",
+    "test": "tsc && node --test test/*.test.mjs",
+    "prepack": "npm run clean && npm run build",
+    "prepublishOnly": "npm test"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "dependencies": {
+    "@mariozechner/pi-ai": "^0.73.1",
+    "@mariozechner/pi-coding-agent": "^0.73.1",
+    "@mariozechner/pi-tui": "^0.73.1",
+    "smol-toml": "^1.9.1"
+  },
+  "devDependencies": {
+    "@xterm/headless": "^5.5.0",
+    "typescript": "^7.0.2"
+  },
+  "optionalDependencies": {
+    "riftri": "^0.6.7"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}