@vigent/cli 0.0.0-stage → 0.2.0

package/dist/engines.js

@@ -0,0 +1,195 @@
+/**
+ * Which agent engines are available, and are they signed in?
+ *
+ * pi runs inside vigent. Claude Code, Codex and OpenCode are the CLIs you
+ * may already have installed; vigent runs them as they are, so each one uses
+ * its own login (vigent never reads their credentials). Detection only runs
+ * their version and login-status commands.
+ */
+import { execFile } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+export const ENGINE_IDS = ["pi", "claude", "codex", "opencode"];
+export const ENGINE_NAMES = {
+    pi: "pi",
+    claude: "Claude Code",
+    codex: "Codex",
+    opencode: "OpenCode",
+};
+export const ENGINE_BINS = {
+    claude: "claude",
+    codex: "codex",
+    opencode: "opencode",
+};
+const INSTALL = {
+    claude: "npm install -g @anthropic-ai/claude-code",
+    codex: "npm install -g @openai/codex",
+    opencode: "npm install -g opencode-ai",
+};
+const PI_KEYS = ["ANTHROPIC_API_KEY", "OPENAI_API_KEY", "GEMINI_API_KEY", "GOOGLE_API_KEY", "MISTRAL_API_KEY", "GROQ_API_KEY", "XAI_API_KEY", "OPENROUTER_API_KEY"];
+export function isEngineId(s) {
+    return ENGINE_IDS.includes(s);
+}
+/** Is this command on PATH? (a quick check, without running it) */
+export function onPath(bin, env = process.env) {
+    const exts = process.platform === "win32" ? (env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";") : [""];
+    for (const dir of (env.PATH ?? "").split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            try {
+                fs.accessSync(path.join(dir, bin + ext), fs.constants.X_OK);
+                return true;
+            }
+            catch {
+                // not here
+            }
+        }
+    }
+    return false;
+}
+/** pi can run: an API key in the environment, or a saved pi login. */
+export function piConnected(env = process.env) {
+    return detectPi(env).connected;
+}
+/**
+ * The engine new agents use when none is given: pi if it has a key, else the
+ * first signed-in CLI (Claude Code, Codex, OpenCode). Before the sign-in checks
+ * finish, the first of those that is installed.
+ */
+export function defaultEngine(engines, env = process.env) {
+    if (engines) {
+        const ready = engines.find((e) => e.connected);
+        if (ready)
+            return ready.id;
+        const installed = engines.find((e) => e.id !== "pi" && e.installed);
+        return installed?.id ?? "pi";
+    }
+    if (piConnected(env))
+        return "pi";
+    for (const id of ["claude", "codex", "opencode"])
+        if (onPath(ENGINE_BINS[id], env))
+            return id;
+    return "pi";
+}
+/** Run a command with a timeout; never throws. */
+function run(cmd, args, timeoutMs, env) {
+    return new Promise((resolve) => {
+        execFile(cmd, args, { timeout: timeoutMs, env, maxBuffer: 1024 * 1024 }, (err, stdout, stderr) => {
+            const code = err ? (err.code === "ENOENT" ? null : (err.code ?? 1)) : 0;
+            resolve({ ok: !err, code: typeof code === "number" ? code : null, stdout: String(stdout ?? ""), stderr: String(stderr ?? "") });
+        });
+    });
+}
+function strip(s) {
+    return s.replace(/\x1b\[[0-9;]*m/g, "");
+}
+function firstVersion(s) {
+    return /\d+\.\d+\.\d+[\w.-]*/.exec(s)?.[0];
+}
+function detectPi(env) {
+    const keys = PI_KEYS.filter((k) => env[k]);
+    let stored = false;
+    try {
+        const auth = JSON.parse(fs.readFileSync(path.join(env.HOME ?? os.homedir(), ".pi", "agent", "auth.json"), "utf8"));
+        stored = Object.keys(auth ?? {}).length > 0;
+    }
+    catch {
+        // no pi login stored
+    }
+    const connected = keys.length > 0 || stored;
+    return {
+        id: "pi",
+        name: ENGINE_NAMES.pi,
+        installed: true,
+        connected,
+        detail: connected
+            ? `built in · ${keys.length > 0 ? `using ${keys.join(", ")}` : "using pi's saved login"}`
+            : "built in · no API key found",
+        connect: connected ? undefined : "export ANTHROPIC_API_KEY=… (or OPENAI_API_KEY, GEMINI_API_KEY)",
+    };
+}
+async function detectClaude(env, timeoutMs) {
+    const base = { id: "claude", name: ENGINE_NAMES.claude, install: INSTALL.claude, connect: "claude auth login" };
+    const v = await run("claude", ["--version"], timeoutMs, env);
+    if (v.code === null)
+        return { ...base, installed: false, connected: false, detail: "not installed" };
+    const version = firstVersion(v.stdout);
+    const s = await run("claude", ["auth", "status", "--json"], timeoutMs, env);
+    try {
+        const st = JSON.parse(s.stdout);
+        if (st.loggedIn) {
+            const how = st.authMethod === "api_key" || st.apiKeySource ? "API key" : "Claude account";
+            return { ...base, installed: true, connected: true, version, detail: `signed in (${how})`, connect: undefined };
+        }
+        return { ...base, installed: true, connected: false, version, detail: "not signed in" };
+    }
+    catch {
+        if (env.ANTHROPIC_API_KEY)
+            return { ...base, installed: true, connected: true, version, detail: "using ANTHROPIC_API_KEY", connect: undefined };
+        return { ...base, installed: true, connected: false, version, detail: "couldn't read sign-in status" };
+    }
+}
+async function detectCodex(env, timeoutMs) {
+    const base = { id: "codex", name: ENGINE_NAMES.codex, install: INSTALL.codex, connect: "codex login" };
+    const v = await run("codex", ["--version"], timeoutMs, env);
+    if (v.code === null)
+        return { ...base, installed: false, connected: false, detail: "not installed" };
+    const version = firstVersion(v.stdout);
+    const s = await run("codex", ["login", "status"], timeoutMs, env);
+    const text = strip(`${s.stdout}\n${s.stderr}`).trim();
+    if (s.ok && /logged in/i.test(text) && !/not logged in/i.test(text)) {
+        const line = text.split("\n").find((l) => /logged in/i.test(l)) ?? "signed in";
+        return { ...base, installed: true, connected: true, version, detail: line.trim().replace(/^logged in/i, "signed in"), connect: undefined };
+    }
+    if (env.OPENAI_API_KEY)
+        return { ...base, installed: true, connected: false, version, detail: "not signed in (OPENAI_API_KEY is set: printenv OPENAI_API_KEY | codex login --with-api-key)" };
+    return { ...base, installed: true, connected: false, version, detail: "not signed in" };
+}
+async function detectOpenCode(env, timeoutMs) {
+    const base = { id: "opencode", name: ENGINE_NAMES.opencode, install: INSTALL.opencode, connect: "opencode auth login" };
+    const v = await run("opencode", ["--version"], timeoutMs, env);
+    if (v.code === null)
+        return { ...base, installed: false, connected: false, version: undefined, detail: "not installed" };
+    const version = firstVersion(v.stdout);
+    const s = await run("opencode", ["auth", "list"], timeoutMs, env);
+    const text = strip(`${s.stdout}\n${s.stderr}`);
+    const creds = Number(/(\d+)\s+credentials?/.exec(text)?.[1] ?? 0);
+    const envVars = Number(/(\d+)\s+environment variables?/.exec(text)?.[1] ?? 0);
+    if (creds > 0 || envVars > 0) {
+        const parts = [creds > 0 ? `${creds} saved login${creds === 1 ? "" : "s"}` : "", envVars > 0 ? `${envVars} provider key${envVars === 1 ? "" : "s"} in the environment` : ""].filter(Boolean);
+        return { ...base, installed: true, connected: true, version, detail: parts.join(", "), connect: undefined };
+    }
+    return { ...base, installed: true, connected: false, version, detail: "no providers connected" };
+}
+/**
+ * What's known instantly, without running anything: which CLIs are on PATH,
+ * and pi's keys. Shown at startup while detectEngines() asks the CLIs.
+ */
+export function quickEngines(env = process.env) {
+    return [
+        detectPi(env),
+        ...["claude", "codex", "opencode"].map((id) => {
+            const installed = onPath(ENGINE_BINS[id], env);
+            return {
+                id,
+                name: ENGINE_NAMES[id],
+                installed,
+                connected: false,
+                checking: installed,
+                detail: installed ? "checking sign-in…" : "not installed",
+                install: INSTALL[id],
+            };
+        }),
+    ];
+}
+/** Check every engine in parallel. Each CLI check is bounded by `timeoutMs`. */
+export async function detectEngines(env = process.env, timeoutMs = 8000) {
+    return Promise.all([
+        Promise.resolve(detectPi(env)),
+        detectClaude(env, timeoutMs),
+        detectCodex(env, timeoutMs),
+        detectOpenCode(env, timeoutMs),
+    ]);
+}

package/dist/export.js

@@ -0,0 +1,29 @@
+export function transcriptMarkdown(s, now = new Date()) {
+    const out = [`# ${s.name}`, ""];
+    const meta = [`model: ${s.model}`];
+    if (s.worktree)
+        meta.push(`branch: \`${s.worktree.branch}\``);
+    if (s.worktree?.stat)
+        meta.push(`changes: +${s.worktree.stat.added} −${s.worktree.stat.removed}`);
+    meta.push(`exported: ${now.toISOString().replace("T", " ").slice(0, 16)}`);
+    out.push(meta.join(" · "), "");
+    for (const item of s.items) {
+        switch (item.kind) {
+            case "user":
+                out.push(`## You`, "", item.text, "");
+                break;
+            case "agent":
+                out.push(`## Agent`, "", item.text, "");
+                break;
+            case "tool": {
+                const t = item.tool;
+                out.push(`<details><summary><code>${t.name}</code> ${t.summary}</summary>`, "", "```", t.output.trimEnd(), "```", "", "</details>", "");
+                break;
+            }
+            case "info":
+                out.push(`> ${item.text}`, "");
+                break;
+        }
+    }
+    return `${out.join("\n").trimEnd()}\n`;
+}

package/dist/float.js

@@ -0,0 +1,182 @@
+/**
+ * A scrollable floating window: read-only text (`:help`, `:map`, `:diff`),
+ * optionally with selectable rows (`:dash`) and jump points (`]c` / `[c`
+ * between diff hunks).
+ */
+import { parseKey, truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import { RESET } from "./theme.js";
+export class TextFloat {
+    painter;
+    icons;
+    title;
+    lines;
+    height;
+    onClose;
+    requestRender;
+    opts;
+    top = 0;
+    selected = 0;
+    pending = "";
+    constructor(painter, icons, title, lines, height, onClose, requestRender, opts = {}) {
+        this.painter = painter;
+        this.icons = icons;
+        this.title = title;
+        this.lines = lines;
+        this.height = height;
+        this.onClose = onClose;
+        this.requestRender = requestRender;
+        this.opts = opts;
+        const sel = opts.selectable ?? [];
+        if (sel.length > 0) {
+            this.selected = Math.max(0, opts.initial !== undefined ? sel.indexOf(opts.initial) : 0);
+            this.reveal(sel[this.selected]);
+        }
+    }
+    reveal(line) {
+        const n = this.visible();
+        if (line < this.top)
+            this.top = line;
+        else if (line >= this.top + n)
+            this.top = Math.min(Math.max(0, this.lines.length - n), line - n + 2);
+    }
+    select(delta) {
+        const sel = this.opts.selectable ?? [];
+        if (sel.length === 0)
+            return false;
+        this.selected = Math.max(0, Math.min(sel.length - 1, this.selected + delta));
+        this.reveal(sel[this.selected]);
+        return true;
+    }
+    jump(dir) {
+        const jumps = this.opts.jumps ?? [];
+        const target = dir > 0 ? jumps.find((j) => j > this.top) : [...jumps].reverse().find((j) => j < this.top);
+        if (target !== undefined)
+            this.top = Math.min(target, Math.max(0, this.lines.length - this.visible()));
+    }
+    visible() {
+        return Math.max(3, Math.min(this.lines.length, this.height() - 2));
+    }
+    scroll(delta) {
+        const max = Math.max(0, this.lines.length - this.visible());
+        this.top = Math.max(0, Math.min(max, this.top + delta));
+    }
+    handleInput(data) {
+        const key = parseKey(data) ?? data;
+        if (this.pending) {
+            const p = this.pending;
+            this.pending = "";
+            if ((p === "]" || p === "[") && key === "c")
+                this.jump(p === "]" ? 1 : -1);
+            this.requestRender();
+            return;
+        }
+        switch (key) {
+            case "enter":
+            case "return": {
+                const sel = this.opts.selectable ?? [];
+                this.onClose();
+                if (sel.length > 0)
+                    this.opts.onSelect?.(sel[this.selected]);
+                return;
+            }
+            case "escape":
+            case "q":
+            case "ctrl+c":
+                this.onClose();
+                return;
+            case "]":
+            case "[":
+                this.pending = key;
+                return;
+            case "s": {
+                const alt = this.opts.alternate;
+                if (!alt)
+                    break;
+                this.opts.alternate = { title: this.title, lines: this.lines, jumps: this.opts.jumps };
+                this.title = alt.title;
+                this.lines = alt.lines;
+                this.opts.jumps = alt.jumps;
+                this.top = 0;
+                break;
+            }
+            case "j":
+            case "down":
+                if (!this.select(1))
+                    this.scroll(1);
+                break;
+            case "k":
+            case "up":
+                if (!this.select(-1))
+                    this.scroll(-1);
+                break;
+            case "ctrl+d":
+            case "pageDown":
+            case "space":
+                this.scroll(Math.floor(this.visible() / 2));
+                break;
+            case "ctrl+u":
+            case "pageUp":
+                this.scroll(-Math.floor(this.visible() / 2));
+                break;
+            case "g":
+                this.top = 0;
+                break;
+            case "G":
+            case "shift+g":
+                this.scroll(this.lines.length);
+                break;
+        }
+        this.requestRender();
+    }
+    invalidate() { }
+    render(width) {
+        const P = this.painter;
+        const I = this.icons;
+        const inner = Math.max(10, width - 2);
+        const bg = P.attr("NormalFloat").bg;
+        const border = (s) => P.on("FloatBorder", bg) + s + RESET;
+        const title = ` ${this.title} `;
+        const out = [
+            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 n = this.visible();
+        const selectedLine = (this.opts.selectable ?? [])[this.selected];
+        const selBg = P.attr("PmenuSel").bg ?? P.attr("Visual").bg;
+        this.lines.slice(this.top, this.top + n).forEach((line, i) => {
+            const isSelected = this.top + i === selectedLine;
+            const rowBg = isSelected ? selBg : bg;
+            let text = "";
+            let used = 0;
+            for (const [group, seg] of line) {
+                const t = truncateToWidth(seg, Math.max(0, inner - 1 - used), "…");
+                // the selected row uses the theme's PmenuSel colors so it stays readable
+                text += RESET + P.on(isSelected ? "PmenuSel" : group, rowBg) + t;
+                used += visibleWidth(t);
+            }
+            out.push(border(I.v) +
+                P.on("NormalFloat", rowBg) +
+                " " +
+                text +
+                P.on("NormalFloat", rowBg) +
+                " ".repeat(Math.max(0, inner - 1 - used)) +
+                RESET +
+                border(I.v));
+        });
+        const more = this.lines.length > n ? ` ${this.top + 1}-${Math.min(this.lines.length, this.top + n)}/${this.lines.length} ` : "";
+        const hint = " q close ";
+        out.push(border(I.bl + I.h) +
+            P.on("Comment", bg) +
+            hint +
+            RESET +
+            border(I.h.repeat(Math.max(0, inner - 2 - visibleWidth(hint) - visibleWidth(more)))) +
+            P.on("Comment", bg) +
+            more +
+            RESET +
+            border(I.h + I.br));
+        return out;
+    }
+}

package/dist/import.js

@@ -0,0 +1,260 @@
+/**
+ * Import vim / nvim colorschemes as vigent themes.
+ *
+ *   vigent theme import                  the colorscheme your nvim/vim config uses
+ *   vigent theme import tokyonight       a colorscheme by name (plugins load normally)
+ *   vigent theme import ./molokai.vim    a colorscheme file (works without an editor)
+ *
+ * The editor runs headless with your normal config, loads the colorscheme,
+ * and dumps every resolved highlight group. If that fails it retries without
+ * your config, then with the other editor.
+ */
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { resolveVimColor } from "./color.js";
+import { themesDir } from "./theme.js";
+import { parseHighlightCommand, parseVimColorscheme } from "./vimcolors.js";
+const NVIM_DUMP = `
+local result = { name = vim.g.colors_name, background = vim.o.background }
+local ok, groups = pcall(function()
+  local out = {}
+  for name, hl in pairs(vim.api.nvim_get_hl(0, {})) do
+    local r = hl
+    if hl.link then r = vim.api.nvim_get_hl(0, { name = name, link = false }) end
+    local e = {}
+    if r.fg then e.fg = string.format("#%06x", r.fg) elseif r.ctermfg then e.ctermfg = r.ctermfg end
+    if r.bg then e.bg = string.format("#%06x", r.bg) elseif r.ctermbg then e.ctermbg = r.ctermbg end
+    for _, k in ipairs({ "bold", "italic", "underline", "undercurl", "reverse", "standout" }) do
+      if r[k] then e[k] = true end
+    end
+    if next(e) ~= nil then out[name] = e end
+  end
+  return out
+end)
+if ok then result.groups = groups else result.text = vim.fn.execute("highlight") end
+local encode = (vim.json and vim.json.encode) or vim.fn.json_encode
+local f = assert(io.open(os.getenv("VIGENT_OUT"), "w"))
+f:write(encode(result))
+f:close()
+`;
+const VIM_DUMP = `
+let s:out = {'name': get(g:, 'colors_name', ''), 'background': &background}
+if exists('*hlget')
+  let s:groups = {}
+  for s:h in hlget()
+    let s:r = get(hlget(s:h.name, v:true), 0, {})
+    let s:e = {}
+    for [s:key, s:dst] in [['guifg', 'fg'], ['guibg', 'bg']]
+      if has_key(s:r, s:key)
+        let s:c = s:r[s:key]
+        if s:c !~ '^#' && exists('v:colornames')
+          let s:c = get(v:colornames, tolower(s:c), s:c)
+        endif
+        let s:e[s:dst] = s:c
+      endif
+    endfor
+    if !has_key(s:e, 'fg') && has_key(s:r, 'ctermfg') | let s:e.ctermfg = s:r.ctermfg | endif
+    if !has_key(s:e, 'bg') && has_key(s:r, 'ctermbg') | let s:e.ctermbg = s:r.ctermbg | endif
+    let s:attrs = get(s:r, 'gui', get(s:r, 'cterm', {}))
+    for s:k in ['bold', 'italic', 'underline', 'undercurl', 'reverse', 'inverse', 'standout']
+      if get(s:attrs, s:k, v:false) | let s:e[s:k] = v:true | endif
+    endfor
+    if !empty(s:e) | let s:groups[s:h.name] = s:e | endif
+  endfor
+  let s:out.groups = s:groups
+else
+  let s:out.text = execute('highlight')
+endif
+call writefile([json_encode(s:out)], $VIGENT_OUT)
+`;
+export function hasEditor(editor) {
+    const r = spawnSync(editor, ["--version"], { stdio: "ignore", timeout: 5000 });
+    return r.status === 0;
+}
+function isPath(source) {
+    return /[/\\]/.test(source) || /\.(vim|lua)$/.test(source);
+}
+/** Escape a path for use in a vim command line. */
+function vimEscape(p) {
+    return p.replace(/[ \\|"%#]/g, "\\$&");
+}
+function loadCommand(source) {
+    if (!source)
+        return undefined;
+    if (isPath(source))
+        return `source ${vimEscape(path.resolve(source))}`;
+    if (!/^[\w.\-+]+$/.test(source))
+        throw new Error(`invalid colorscheme name '${source}'`);
+    return `colorscheme ${source}`;
+}
+function vimrcArgs() {
+    const home = os.homedir();
+    for (const f of [path.join(home, ".vimrc"), path.join(home, ".vim", "vimrc")]) {
+        if (fs.existsSync(f))
+            return ["-u", f];
+    }
+    return ["-u", "NONE"];
+}
+function runEditor(editor, opts, clean) {
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "vigent-import-"));
+    const out = path.join(tmp, "dump.json");
+    const script = path.join(tmp, editor === "nvim" ? "dump.lua" : "dump.vim");
+    fs.writeFileSync(script, editor === "nvim" ? NVIM_DUMP : VIM_DUMP);
+    const cmds = ["set termguicolors"];
+    if (opts.background)
+        cmds.push(`set background=${opts.background}`);
+    const load = loadCommand(opts.source);
+    if (load)
+        cmds.push(load);
+    cmds.push(editor === "nvim" ? `luafile ${vimEscape(script)}` : `source ${vimEscape(script)}`);
+    cmds.push("qa!");
+    const args = editor === "nvim"
+        ? ["--headless", ...(clean ? ["--clean"] : []), ...cmds.flatMap((c) => ["-c", c])]
+        : [
+            "-es", "-N", "-i", "NONE",
+            ...(clean ? ["-u", "NONE"] : vimrcArgs()),
+            "-c", "silent! packloadall",
+            ...cmds.flatMap((c) => ["-c", c]),
+        ];
+    try {
+        spawnSync(editor, args, {
+            env: { ...process.env, VIGENT_OUT: out },
+            stdio: ["ignore", "ignore", "pipe"],
+            timeout: 60_000,
+        });
+        if (!fs.existsSync(out))
+            return undefined;
+        return JSON.parse(fs.readFileSync(out, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        fs.rmSync(tmp, { recursive: true, force: true });
+    }
+}
+/** The name a colorscheme file sets (g:colors_name), if it says. */
+function declaredName(file) {
+    try {
+        const text = fs.readFileSync(file, "utf8");
+        return /colors_name\s*=\s*['"]([^'"]+)['"]/.exec(text)?.[1];
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Did the editor actually switch to the requested colorscheme? (a failed load keeps the old one) */
+function loadedRequested(dump, source) {
+    if (!dump.groups && !dump.text)
+        return false;
+    if (!source)
+        return true;
+    if (isPath(source)) {
+        const expected = declaredName(source);
+        return expected === undefined || dump.name === expected;
+    }
+    return dump.name === source;
+}
+function dumpToGroups(dump) {
+    const groups = {};
+    if (dump.groups) {
+        for (const [name, e] of Object.entries(dump.groups)) {
+            const attr = {};
+            const color = (v, cterm) => v === undefined || v === "" ? undefined : resolveVimColor(String(v), cterm);
+            attr.fg = color(e.fg, false) ?? color(e.ctermfg, true);
+            attr.bg = color(e.bg, false) ?? color(e.ctermbg, true);
+            if (e.bold)
+                attr.bold = true;
+            if (e.italic)
+                attr.italic = true;
+            if (e.underline || e.undercurl)
+                attr.underline = true;
+            if (e.reverse || e.inverse || e.standout)
+                attr.reverse = true;
+            if (attr.fg === undefined)
+                delete attr.fg;
+            if (attr.bg === undefined)
+                delete attr.bg;
+            if (Object.keys(attr).length > 0)
+                groups[name] = attr;
+        }
+        return groups;
+    }
+    return parseHighlightListing(dump.text ?? "");
+}
+/** Parse the output of `:highlight` (used for editors without nvim_get_hl / hlget). */
+export function parseHighlightListing(text) {
+    const groups = {};
+    const entries = text.split("\n").reduce((acc, line) => {
+        if (/^\s/.test(line) && acc.length > 0)
+            acc[acc.length - 1] += ` ${line.trim()}`;
+        else if (line.trim())
+            acc.push(line.trim());
+        return acc;
+    }, []);
+    for (const entry of entries) {
+        const m = /^(\S+)\s+xxx\s+(.*)$/.exec(entry);
+        if (!m)
+            continue;
+        const link = /links to (\S+)/.exec(m[2]);
+        const own = m[2].replace(/links to \S+/, "").trim();
+        const cmd = own ? parseHighlightCommand(`${m[1]} ${own}`) : undefined;
+        if (cmd?.kind === "set" && Object.keys(cmd.attr).length > 0)
+            groups[m[1]] = cmd.attr;
+        else if (link)
+            groups[m[1]] = { link: link[1] };
+    }
+    return groups;
+}
+export function importTheme(opts = {}) {
+    const editors = opts.editor ? [opts.editor] : ["nvim", "vim"];
+    const available = editors.filter(hasEditor);
+    let dump;
+    let via = "";
+    for (const editor of available) {
+        const modes = opts.clean ? [true] : opts.source ? [false, true] : [false];
+        for (const clean of modes) {
+            const d = runEditor(editor, opts, clean);
+            if (d && loadedRequested(d, opts.source)) {
+                dump = d;
+                via = `${editor}${clean ? " --clean" : ""}`;
+                break;
+            }
+        }
+        if (dump)
+            break;
+    }
+    let groups;
+    let name;
+    let background;
+    if (dump) {
+        groups = dumpToGroups(dump);
+        name = opts.as ?? (dump.name || (opts.source ? path.basename(opts.source).replace(/\.(vim|lua)$/, "") : "current"));
+        background = dump.background;
+    }
+    else if (opts.source && isPath(opts.source) && opts.source.endsWith(".vim") && fs.existsSync(opts.source)) {
+        const parsed = parseVimColorscheme(fs.readFileSync(opts.source, "utf8"), opts.background);
+        groups = parsed.groups;
+        name = opts.as ?? parsed.name ?? path.basename(opts.source, ".vim");
+        background = parsed.background;
+        via = "static parse";
+    }
+    else if (available.length === 0) {
+        throw new Error("neither nvim nor vim was found on PATH. Install one, or import a .vim file directly: vigent theme import ./theme.vim");
+    }
+    else if (opts.source) {
+        throw new Error(`${available.join(" and ")} could not load colorscheme '${opts.source}'`);
+    }
+    else {
+        throw new Error(`could not read the current colorscheme from ${available.join(" or ")}`);
+    }
+    if (!/^[\w.\-+]+$/.test(name))
+        name = name.replace(/[^\w.\-+]+/g, "-");
+    const dir = opts.outDir ?? themesDir();
+    fs.mkdirSync(dir, { recursive: true });
+    const file = path.join(dir, `${name}.json`);
+    fs.writeFileSync(file, `${JSON.stringify({ name, background, source: via, groups }, null, "\t")}\n`);
+    return { name, file, groups: Object.keys(groups).length, via };
+}