agent-toggle 0.1.0

package/dist/core/jsonio.js

@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { applyEdits, modify, parse } from "jsonc-parser";
+import { t } from "./i18n.js";
+export const HOME = os.homedir();
+/** agent-toggle's own data: stash, groups, backups, preferences. */
+export const STATE_DIR = path.join(HOME, ".agent-toggle");
+export const BACKUP_DIR = path.join(STATE_DIR, "backups");
+export const state = { dryRun: false, changes: [] };
+export const home = (...p) => path.join(HOME, ...p);
+/** Path comparison key: case-insensitive on Windows only (Linux file systems are case-sensitive). */
+export const pathKey = (p) => {
+    const r = path.resolve(p).replace(/\\/g, "/");
+    return process.platform === "win32" ? r.toLowerCase() : r;
+};
+function readText(file) {
+    try {
+        return fs.readFileSync(file, "utf8").replace(/^/, "");
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return undefined;
+        throw e;
+    }
+}
+/** Reads JSON or JSONC (comments and trailing commas allowed). */
+export function readJson(file, fallback = {}) {
+    const raw = readText(file);
+    if (raw === undefined || !raw.trim())
+        return structuredClone(fallback);
+    const errors = [];
+    const data = parse(raw, errors, { allowTrailingComma: true, disallowComments: false });
+    if (errors.length && (data === undefined || typeof data !== "object"))
+        throw new Error(t("err.badJson", { file }));
+    return data ?? structuredClone(fallback);
+}
+const backedUp = new Set();
+/** Backs the file up once per run, before the first write. */
+function backup(file) {
+    if (backedUp.has(file) || !fs.existsSync(file))
+        return;
+    fs.mkdirSync(BACKUP_DIR, { recursive: true });
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const name = file.replace(/[:\\/]+/g, "_").replace(/^_+/, "");
+    fs.copyFileSync(file, path.join(BACKUP_DIR, `${stamp}__${name}`));
+    backedUp.add(file);
+    // Keep only the 20 most recent copies of each file.
+    const copies = fs.readdirSync(BACKUP_DIR).filter((f) => f.endsWith(`__${name}`)).sort();
+    for (const old of copies.slice(0, -20))
+        fs.rmSync(path.join(BACKUP_DIR, old), { force: true });
+}
+export function writeText(file, text, what) {
+    state.changes.push(what);
+    if (state.dryRun)
+        return;
+    backup(file);
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    const tmp = `${file}.tmp-${process.pid}`;
+    fs.writeFileSync(tmp, text, "utf8");
+    fs.renameSync(tmp, file);
+}
+/** Rewrites the whole file (plain JSON, no comments). */
+export function writeJson(file, data, what) {
+    writeText(file, JSON.stringify(data, null, 2) + "\n", what);
+}
+/**
+ * Edits precise paths while keeping comments and formatting
+ * (essential for .jsonc). value undefined = removal.
+ */
+export function editJson(file, what, ops) {
+    let text = readText(file) ?? "{}\n";
+    const indent = /\n(\t| +)"/.exec(text)?.[1] ?? "  ";
+    const opts = { formattingOptions: { insertSpaces: !indent.startsWith("\t"), tabSize: indent.length, eol: text.includes("\r\n") ? "\r\n" : "\n" } };
+    const tree = () => parse(text, [], { allowTrailingComma: true }) ?? {};
+    const empty = (o) => !!o && typeof o === "object" && !Array.isArray(o) && !Object.keys(o).length;
+    for (const op of ops) {
+        const before = tree();
+        text = applyEdits(text, modify(text, op.path, op.value, opts));
+        if (op.value !== undefined)
+            continue;
+        // A removal that empties a parent object removes the parent too (unless it was already empty).
+        for (let d = op.path.length - 1; d > 0; d--) {
+            const parent = op.path.slice(0, d);
+            if (!empty(getPath(tree(), parent)) || empty(getPath(before, parent)))
+                break;
+            text = applyEdits(text, modify(text, parent, undefined, opts));
+        }
+    }
+    writeText(file, text, what);
+}
+export function getPath(data, p) {
+    return p.reduce((o, k) => (o == null ? undefined : o[k]), data);
+}
+/** Moves a file or a link (symlinks/junctions included) without following its target. */
+export function moveEntry(from, to, what) {
+    state.changes.push(what);
+    if (state.dryRun)
+        return;
+    if (fs.existsSync(to))
+        throw new Error(t("err.destExists", { path: to }));
+    fs.mkdirSync(path.dirname(to), { recursive: true });
+    fs.renameSync(from, to);
+}
+export function isLink(p) {
+    try {
+        return fs.lstatSync(p).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+export function listDir(dir) {
+    try {
+        return fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+export function exists(p) {
+    return fs.existsSync(p);
+}
+export function toggleInList(list, name, present) {
+    const set = new Set(list ?? []);
+    if (present)
+        set.add(name);
+    else
+        set.delete(name);
+    return [...set];
+}
+/** "<what> → enabled/disabled (<where>)": the standard change message. */
+export function toggled(what, enabled, where) {
+    const s = t(enabled ? "state.enabled" : "state.disabled");
+    return where ? t("change.toggleAt", { what, state: s, where }) : t("change.toggle", { what, state: s });
+}

package/dist/core/logo.js

@@ -0,0 +1,128 @@
+/*
+ * CLI logo: figlet "ANSI Shadow" art with a diagonal gradient, #C77DFF (top-left)
+ * to #3A86FF (bottom-right). Colors are interpolated in OKLab (perceptually even
+ * steps) and the angle accounts for terminal cells being about twice as tall
+ * as they are wide, so the gradient runs at a true 45°. Shadow glyphs
+ * (╗ ║ ═ …) are drawn slightly darker to give the letters some depth.
+ * Generated by ascii-logo: do not edit the WIDE/STACKED arrays by hand.
+ */
+const WIDE = [
+    " █████╗  ██████╗     ████████╗ ██████╗  ██████╗  ██████╗ ██╗     ███████╗",
+    "██╔══██╗██╔════╝     ╚══██╔══╝██╔═══██╗██╔════╝ ██╔════╝ ██║     ██╔════╝",
+    "███████║██║  ███╗       ██║   ██║   ██║██║  ███╗██║  ███╗██║     █████╗",
+    "██╔══██║██║   ██║       ██║   ██║   ██║██║   ██║██║   ██║██║     ██╔══╝",
+    "██║  ██║╚██████╔╝       ██║   ╚██████╔╝╚██████╔╝╚██████╔╝███████╗███████╗",
+    "╚═╝  ╚═╝ ╚═════╝        ╚═╝    ╚═════╝  ╚═════╝  ╚═════╝ ╚══════╝╚══════╝"
+];
+const STACKED = [
+    " █████╗  ██████╗",
+    "██╔══██╗██╔════╝",
+    "███████║██║  ███╗",
+    "██╔══██║██║   ██║",
+    "██║  ██║╚██████╔╝",
+    "╚═╝  ╚═╝ ╚═════╝",
+    "",
+    "████████╗ ██████╗  ██████╗  ██████╗ ██╗     ███████╗",
+    "╚══██╔══╝██╔═══██╗██╔════╝ ██╔════╝ ██║     ██╔════╝",
+    "   ██║   ██║   ██║██║  ███╗██║  ███╗██║     █████╗",
+    "   ██║   ██║   ██║██║   ██║██║   ██║██║     ██╔══╝",
+    "   ██║   ╚██████╔╝╚██████╔╝╚██████╔╝███████╗███████╗",
+    "   ╚═╝    ╚═════╝  ╚═════╝  ╚═════╝ ╚══════╝╚══════╝"
+];
+const PLAIN = "AG TOGGLE";
+/** Gradient stops, sRGB. */
+export const FROM = [199, 125, 255]; // #C77DFF
+export const TO = [58, 134, 255]; // #3A86FF
+/** Lightness factor of shadow glyphs (1 = same as the letters). */
+const SHADOW_DIM = 0.72;
+const toLinear = (c) => ((c /= 255) <= 0.04045 ? c / 12.92 : ((c + 0.055) / 1.055) ** 2.4);
+const toSrgb = (c) => Math.round(255 * Math.min(1, Math.max(0, c <= 0.0031308 ? 12.92 * c : 1.055 * c ** (1 / 2.4) - 0.055)));
+function rgbToOklab([r, g, b]) {
+    const [lr, lg, lb] = [toLinear(r), toLinear(g), toLinear(b)];
+    const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+    const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+    const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+    return [
+        0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+        1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+        0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    ];
+}
+function oklabToRgb([L, a, b]) {
+    const l = (L + 0.3963377774 * a + 0.2158037573 * b) ** 3;
+    const m = (L - 0.1055613458 * a - 0.0638541728 * b) ** 3;
+    const s = (L - 0.0894841775 * a - 1.291485548 * b) ** 3;
+    return [
+        toSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+        toSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+        toSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
+    ];
+}
+const A = rgbToOklab(FROM);
+const B = rgbToOklab(TO);
+/** Color at position t ∈ [0, 1]; dim < 1 darkens (OKLab lightness) for shadow glyphs. */
+export function gradientAt(t, dim = 1) {
+    const k = Math.min(1, Math.max(0, t));
+    return oklabToRgb([(A[0] + (B[0] - A[0]) * k) * dim, A[1] + (B[1] - A[1]) * k, A[2] + (B[2] - A[2]) * k]);
+}
+/** Terminal color depth, from the usual environment hints. */
+export function colorDepth(stream = process.stdout) {
+    const env = process.env;
+    if ("NO_COLOR" in env || env.TERM === "dumb" || !stream.isTTY)
+        return "none";
+    if ("FORCE_COLOR" in env && env.FORCE_COLOR === "0")
+        return "none";
+    if (/^(truecolor|24bit)$/i.test(env.COLORTERM ?? "") || env.WT_SESSION || env.TERM_PROGRAM === "vscode" ||
+        env.TERM_PROGRAM === "iTerm.app" || env.TERM_PROGRAM === "WezTerm" || /-direct$|kitty|alacritty/.test(env.TERM ?? "") ||
+        process.platform === "win32")
+        return "truecolor";
+    return "256";
+}
+/** Nearest xterm-256 color (6×6×6 cube or grey ramp). */
+function to256([r, g, b]) {
+    const cube = (c) => (c < 48 ? 0 : c < 115 ? 1 : Math.floor((c - 35) / 40));
+    const levels = [0, 95, 135, 175, 215, 255];
+    const [cr, cg, cb] = [cube(r), cube(g), cube(b)];
+    const cubeDist = (levels[cr] - r) ** 2 + (levels[cg] - g) ** 2 + (levels[cb] - b) ** 2;
+    const grey = Math.min(23, Math.max(0, Math.round(((r + g + b) / 3 - 8) / 10)));
+    const gv = 8 + grey * 10;
+    const greyDist = (gv - r) ** 2 + (gv - g) ** 2 + (gv - b) ** 2;
+    return greyDist < cubeDist ? 232 + grey : 16 + 36 * cr + 6 * cg + cb;
+}
+const SHADOW = /[╔╗╚╝═║]/;
+/** Paints an art block with the diagonal gradient. */
+export function paint(lines, depth) {
+    if (depth === "none")
+        return lines.join("\n");
+    const h = lines.length;
+    const w = Math.max(...lines.map((l) => l.length));
+    // Cells are ~2× taller than wide: weighting rows by 2 keeps the angle at 45°.
+    const span = Math.max(1, w - 1 + 2 * (h - 1));
+    return lines.map((line, y) => {
+        let out = "";
+        let last = "";
+        for (let x = 0; x < line.length; x++) {
+            const ch = line[x];
+            if (ch === " ") {
+                out += ch;
+                continue;
+            }
+            const rgb = gradientAt((x + 2 * y) / span, SHADOW.test(ch) ? SHADOW_DIM : 1);
+            const code = depth === "truecolor" ? `38;2;${rgb[0]};${rgb[1]};${rgb[2]}` : `38;5;${to256(rgb)}`;
+            if (code !== last)
+                out += `\x1b[${code}m`;
+            last = code;
+            out += ch;
+        }
+        return out + "\x1b[0m";
+    }).join("\n");
+}
+/** Logo that fits the terminal width: wide, stacked, then plain text. */
+export function logo(columns = process.stdout.columns ?? 80, depth = colorDepth()) {
+    const fits = (ls) => Math.max(...ls.map((l) => l.length)) <= columns;
+    if (fits(WIDE))
+        return paint(WIDE, depth);
+    if (fits(STACKED))
+        return paint(STACKED, depth);
+    return paint([PLAIN], depth);
+}

package/dist/core/stash.js

@@ -0,0 +1,21 @@
+import path from "node:path";
+import { pathKey, readJson, STATE_DIR, writeJson } from "./jsonio.js";
+export const stashFile = path.join(STATE_DIR, "stash.json");
+export function readStash() {
+    const s = readJson(stashFile, { entries: [] });
+    return { entries: s.entries ?? [] };
+}
+export function stashed(agent, file) {
+    const norm = pathKey(file);
+    return readStash().entries.filter((e) => e.agent === agent && pathKey(e.file) === norm);
+}
+export function updateStash(what, fn) {
+    const s = readStash();
+    fn(s);
+    writeJson(stashFile, s, what);
+}
+export function sameEntry(a, b) {
+    return a.agent === b.agent && pathKey(a.file) === pathKey(b.file) &&
+        a.kind === b.kind && JSON.stringify(a.path) === JSON.stringify(b.path) &&
+        (b.value === undefined || JSON.stringify(a.value) === JSON.stringify(b.value));
+}

package/dist/core/toml.js

@@ -0,0 +1,138 @@
+import fs from "node:fs";
+import { parse } from "smol-toml";
+import { writeText } from "./jsonio.js";
+import { t } from "./i18n.js";
+export function readToml(file) {
+    try {
+        return parse(fs.readFileSync(file, "utf8").replace(/^/, ""));
+    }
+    catch (e) {
+        if (e.code === "ENOENT")
+            return {};
+        throw new Error(t("err.badToml", { file, msg: e.message }));
+    }
+}
+const esc = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const keyAlt = (k) => `(?:${esc(k)}|"${esc(k)}"|'${esc(k)}')`;
+const bare = (k) => (/^[A-Za-z0-9_-]+$/.test(k) ? k : JSON.stringify(k));
+function headerRe(table, array = false) {
+    const [o, c] = array ? ["\\[\\[", "\\]\\]"] : ["\\[", "\\]"];
+    return new RegExp(`^\\s*${o}\\s*${table.map(keyAlt).join("\\s*\\.\\s*")}\\s*${c}\\s*(#.*)?$`);
+}
+const isHeader = (l) => /^\s*\[/.test(l);
+function fmt(v) {
+    if (Array.isArray(v))
+        return `[${v.map((x) => JSON.stringify(x)).join(", ")}]`;
+    return typeof v === "string" ? JSON.stringify(v) : String(v);
+}
+function load(file) {
+    const text = fs.existsSync(file) ? fs.readFileSync(file, "utf8") : "";
+    return { eol: text.includes("\r\n") ? "\r\n" : "\n", lines: text ? text.split(/\r?\n/) : [] };
+}
+/**
+ * Sets a key in a table (table [] = file root); value undefined removes it.
+ * The table is created at the end of the file when missing.
+ */
+export function setTomlKey(file, table, key, value, what) {
+    const { eol, lines } = load(file);
+    const line = value === undefined ? undefined : `${bare(key)} = ${fmt(value)}`;
+    let start = table.length ? lines.findIndex((l) => headerRe(table).test(l)) : -1;
+    if (table.length && start < 0) {
+        if (line === undefined)
+            return;
+        while (lines.length && !lines.at(-1).trim())
+            lines.pop();
+        lines.push("", `[${table.map(bare).join(".")}]`, line, "");
+        return writeText(file, withEol(lines, eol), what);
+    }
+    let end = lines.findIndex((l, i) => i > start && isHeader(l));
+    if (end < 0)
+        end = lines.length;
+    const keyRe = new RegExp(`^\\s*${keyAlt(key)}\\s*=`);
+    const at = lines.findIndex((l, i) => i > start && i < end && keyRe.test(l));
+    if (at >= 0) {
+        if (line === undefined) {
+            lines.splice(at, 1);
+            // Table left empty: remove its header too (and the blank line before it).
+            const body = lines.slice(start + 1, end - 1);
+            if (table.length && body.every((l) => !l.trim()))
+                lines.splice(start - (start > 0 && !lines[start - 1].trim() ? 1 : 0), end - 1 - start + (start > 0 && !lines[start - 1].trim() ? 1 : 0));
+        }
+        else
+            lines[at] = line;
+    }
+    else if (line !== undefined) {
+        // At the root: before the first table; otherwise right below the header.
+        lines.splice(table.length ? start + 1 : end, 0, line);
+    }
+    else
+        return;
+    writeText(file, withEol(lines, eol), what);
+}
+/** Successive [[table]] blocks: start/end indexes and parsed content. */
+function arrayBlocks(lines, table) {
+    const out = [];
+    lines.forEach((l, i) => {
+        if (!headerRe(table, true).test(l))
+            return;
+        let end = lines.findIndex((x, j) => j > i && isHeader(x));
+        if (end < 0)
+            end = lines.length;
+        let data = {};
+        try {
+            data = parse(lines.slice(i + 1, end).join("\n"));
+        }
+        catch { /* unreadable block: ignored */ }
+        out.push({ start: i, end, data });
+    });
+    return out;
+}
+export function addArrayTable(file, table, entries, what) {
+    const { eol, lines } = load(file);
+    while (lines.length && !lines.at(-1).trim())
+        lines.pop();
+    lines.push("", `[[${table.map(bare).join(".")}]]`, ...Object.entries(entries).map(([k, v]) => `${bare(k)} = ${fmt(v)}`), "");
+    writeText(file, withEol(lines, eol), what);
+}
+export function removeArrayTables(file, table, match, what) {
+    const { eol, lines } = load(file);
+    const blocks = arrayBlocks(lines, table).filter((b) => match(b.data));
+    if (!blocks.length)
+        return;
+    for (const b of blocks.reverse()) {
+        let end = b.end;
+        while (end - 1 > b.start && !lines[end - 1].trim())
+            end--;
+        lines.splice(b.start, end - b.start + (lines[end] !== undefined && !lines[end].trim() ? 1 : 0));
+    }
+    writeText(file, withEol(lines, eol), what);
+}
+/** Always a final newline, like editors and the agents' own CLIs do. */
+function withEol(lines, eol) {
+    const out = lines.join(eol);
+    return out.endsWith(eol) ? out : out + eol;
+}
+/**
+ * Sets (or removes) a key in the [[table]] block matching a predicate
+ * (e.g. the [[mcp_servers]] block whose name = "x").
+ */
+export function setArrayTableKey(file, table, match, key, value, what) {
+    const { eol, lines } = load(file);
+    const block = arrayBlocks(lines, table).find((b) => match(b.data));
+    if (!block)
+        return;
+    const keyRe = new RegExp(`^\\s*${keyAlt(key)}\\s*=`);
+    const at = lines.findIndex((l, i) => i > block.start && i < block.end && keyRe.test(l));
+    const line = value === undefined ? undefined : `${bare(key)} = ${fmt(value)}`;
+    if (at >= 0) {
+        if (line === undefined)
+            lines.splice(at, 1);
+        else
+            lines[at] = line;
+    }
+    else if (line !== undefined)
+        lines.splice(block.start + 1, 0, line);
+    else
+        return;
+    writeText(file, withEol(lines, eol), what);
+}

package/dist/core/types.js

@@ -0,0 +1,4 @@
+import { t } from "./i18n.js";
+export const scopeLabel = (s) => t(`scope.${s}`);
+export const SECTION_KINDS = ["mcp", "plugins", "skills", "hooks", "commands", "agents"];
+export const sectionKindTitle = (k) => t(`section.${k}`);

package/dist/core/yaml.js

@@ -0,0 +1,31 @@
+import fs from "node:fs";
+import { parseDocument } from "yaml";
+import { writeText } from "./jsonio.js";
+import { t } from "./i18n.js";
+/*
+ * YAML editing through the yaml Document API: only the targeted nodes change,
+ * comments and the rest of the formatting are kept.
+ */
+function load(file) {
+    const text = fs.existsSync(file) ? fs.readFileSync(file, "utf8").replace(/^/, "") : "";
+    const doc = parseDocument(text);
+    if (doc.errors.length)
+        throw new Error(t("err.badYaml", { file, msg: doc.errors[0].message }));
+    return doc;
+}
+export function readYaml(file) {
+    if (!fs.existsSync(file))
+        return {};
+    return load(file).toJS() ?? {};
+}
+/** Sets (or removes, value undefined) several paths, then writes the file once. */
+export function editYaml(file, what, ops) {
+    const doc = load(file);
+    for (const op of ops) {
+        if (op.value === undefined)
+            doc.deleteIn(op.path);
+        else
+            doc.setIn(op.path, op.value);
+    }
+    writeText(file, String(doc), what);
+}