agent-toggle 0.1.0

package/dist/agents/others.js

@@ -0,0 +1,192 @@
+import path from "node:path";
+import { dirSection, hooksSection, listSection, mcpSection, shortPath } from "../core/generic.js";
+import { editJson, exists, getPath, home, readJson, toggled } from "../core/jsonio.js";
+import { t } from "../core/i18n.js";
+import { mcpGroup } from "../core/groups.js";
+import { skillsIn } from "./_skills.js";
+// ------------------------------------------------------------------ Kiro
+const K = process.env.KIRO_HOME ?? home(".kiro");
+export const kiro = {
+    id: "kiro",
+    name: "Kiro CLI",
+    bins: ["kiro-cli", "kiro"],
+    // Windows installer folder; elsewhere the kiro-cli binary is enough.
+    dirs: process.platform === "win32" ? [path.join(process.env.LOCALAPPDATA ?? home("AppData", "Local"), "Kiro-Cli")] : [],
+    sections: [
+        mcpSection({
+            agent: "kiro",
+            files: { user: () => path.join(K, "settings", "mcp.json"), project: (c) => path.join(c.root, ".kiro", "settings", "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+        }),
+        dirSection({
+            kind: "skills",
+            dirs: { user: () => path.join(K, "skills"), project: (c) => path.join(c.root, ".kiro", "skills") },
+            entry: { dir: "SKILL.md" },
+            note: "note.linkMoved",
+        }),
+        dirSection({ kind: "commands", title: "title.kiroPrompts", dirs: { user: () => path.join(K, "prompts"), project: (c) => path.join(c.root, ".kiro", "prompts") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(K, "agents"), project: (c) => path.join(c.root, ".kiro", "agents") }, entry: { ext: [".json"] } }),
+    ],
+};
+// ------------------------------------------------------------------ Amp
+/** Amp accepts settings.json or settings.jsonc: write to the one that exists. */
+const ampFile = (dir) => (exists(path.join(dir, "settings.jsonc")) ? path.join(dir, "settings.jsonc") : path.join(dir, "settings.json"));
+const AMP = home(".config", "amp");
+export const amp = {
+    id: "amp",
+    name: "Amp",
+    bins: ["amp"],
+    dirs: [".amp", ".config/amp"],
+    sections: [
+        mcpSection({
+            agent: "amp",
+            files: { user: () => ampFile(AMP), project: (c) => ampFile(path.join(c.root, ".amp")) },
+            key: ["amp.mcpServers"],
+            disable: { type: "stash" },
+        }),
+        dirSection({ kind: "plugins", dirs: { user: () => path.join(AMP, "plugins"), project: (c) => path.join(c.root, ".amp", "plugins") }, entry: { ext: [".ts", ".js"] } }),
+        dirSection({
+            kind: "skills",
+            dirs: { user: () => path.join(AMP, "skills"), project: (c) => path.join(c.root, ".agents", "skills") },
+            entry: { dir: "SKILL.md" },
+            note: "note.linkMoved",
+        }),
+    ],
+    notes: ["notes.amp.plugins"],
+};
+/** Adapter shared by OpenCode and its forks: same config shape (mcp, agent, permission). */
+function openCodeSections(o) {
+    const files = (dir) => o.names.map((f) => path.join(dir, f)).filter(exists);
+    const dirOf = (ctx, scope) => (scope === "user" ? o.dir : ctx.root);
+    /** File to write to: the one already defining the key, otherwise the last loaded. */
+    const target = (dir, keyPath) => {
+        const fs = files(dir);
+        return fs.slice().reverse().find((f) => getPath(readJson(f), keyPath) !== undefined) ?? fs.at(-1) ?? path.join(dir, o.names[1] ?? o.names[0]);
+    };
+    const merged = (dir) => files(dir).map((f) => readJson(f));
+    const mcp = {
+        kind: "mcp",
+        scopes: ["user", "project"],
+        note: (s, c) => `${files(dirOf(c, s)).map(shortPath).join(" + ") || t("note.noFile")} · mcp.<name>.enabled = false`,
+        list(ctx, scope) {
+            const m = new Map();
+            for (const data of merged(dirOf(ctx, scope)))
+                for (const [id, d] of Object.entries(data.mcp ?? {}))
+                    m.set(id, { id, label: id, hint: d.url ?? [d.command].flat().join(" "), group: mcpGroup(id), enabled: d.enabled !== false });
+            return [...m.values()];
+        },
+        set(ctx, scope, item, enabled) {
+            const file = target(dirOf(ctx, scope), ["mcp", item.id]);
+            editJson(file, toggled(`MCP ${item.id}`, enabled, shortPath(file)), [{ path: ["mcp", item.id, "enabled"], value: enabled }]);
+        },
+    };
+    const agents = {
+        kind: "agents",
+        scopes: ["user", "project"],
+        note: () => t("note.opencodeAgents"),
+        list(ctx, scope) {
+            const conf = Object.assign({}, ...merged(dirOf(ctx, scope)).map((d) => d.agent ?? {}));
+            const base = scope === "user" ? o.dir : path.join(ctx.root, o.projectDir);
+            const found = [path.join(base, "agent"), path.join(base, "agents")].flatMap((d) => dirSection({ kind: "agents", dirs: { user: () => d }, entry: { ext: [".md"] } }).list(ctx, "user").map((i) => i.label));
+            const ids = new Set([...(scope === "user" ? o.builtinAgents : []), ...found, ...Object.keys(conf)]);
+            return [...ids].sort().map((id) => ({
+                id, label: id, group: t(o.builtinAgents.includes(id) ? "group.builtin" : "group.custom"), enabled: conf[id]?.disable !== true,
+            }));
+        },
+        set(ctx, scope, item, enabled) {
+            const file = target(dirOf(ctx, scope), ["agent", item.id]);
+            editJson(file, toggled(`Agent ${item.id}`, enabled, shortPath(file)), [{ path: ["agent", item.id, "disable"], value: enabled ? undefined : true }]);
+        },
+    };
+    const skills = o.skillPermission
+        ? {
+            kind: "skills",
+            scopes: ["user", "project"],
+            note: () => "permission.skill.<name> = \"deny\"",
+            list(ctx, scope) {
+                const perms = Object.assign({}, ...merged(dirOf(ctx, scope)).map((d) => d.permission?.skill ?? {}));
+                const found = scope === "user"
+                    ? skillsIn(o.userSkillDirs, t("group.user"))
+                    : skillsIn([`${o.projectDir}/skills`, ".claude/skills", ".agents/skills"].map((d) => path.join(ctx.root, d)), t("group.project"));
+                return found.map((s) => ({ id: s.id, label: s.id, hint: s.hint, group: s.group, enabled: perms[s.id] !== "deny" }))
+                    .sort((a, b) => a.label.localeCompare(b.label));
+            },
+            set(ctx, scope, item, enabled) {
+                const file = target(dirOf(ctx, scope), ["permission", "skill"]);
+                editJson(file, toggled(`Skill ${item.id}`, enabled, shortPath(file)), [{ path: ["permission", "skill", item.id], value: enabled ? undefined : "deny" }]);
+            },
+        }
+        : dirSection({ kind: "skills", dirs: { user: () => o.userSkillDirs[0], project: (c) => path.join(c.root, o.projectDir, "skills") }, entry: { dir: "SKILL.md" } });
+    return [
+        mcp,
+        dirSection({ kind: "plugins", dirs: { user: () => path.join(o.dir, "plugins"), project: (c) => path.join(c.root, o.projectDir, "plugins") }, entry: { ext: [".ts", ".js"] } }),
+        skills,
+        dirSection({ kind: "commands", dirs: { user: () => path.join(o.dir, "command"), project: (c) => path.join(c.root, o.projectDir, "command") }, entry: { ext: [".md"] } }),
+        agents,
+    ];
+}
+const OC = process.env.OPENCODE_CONFIG_DIR ?? home(".config", "opencode");
+export const opencode = {
+    id: "opencode",
+    name: "OpenCode",
+    bins: ["opencode"],
+    dirs: [".config/opencode", ".opencode"],
+    sections: openCodeSections({
+        dir: OC,
+        names: ["config.json", "opencode.json", "opencode.jsonc"],
+        projectDir: ".opencode",
+        builtinAgents: ["build", "plan", "general", "explore"],
+        skillPermission: true,
+        userSkillDirs: [path.join(OC, "skills"), home(".claude", "skills"), home(".agents", "skills")],
+    }),
+    notes: ["notes.opencode.hooks"],
+};
+const KILO = process.env.KILO_CONFIG_DIR ?? home(".config", "kilo");
+export const kilo = {
+    id: "kilo",
+    name: "Kilo Code CLI",
+    bins: ["kilo", "kilocode"],
+    dirs: [".config/kilo", ".kilo"],
+    sections: openCodeSections({
+        dir: KILO,
+        names: ["config.json", "opencode.json", "opencode.jsonc", "kilo.json", "kilo.jsonc"],
+        projectDir: ".kilo",
+        builtinAgents: [],
+        skillPermission: false,
+        userSkillDirs: [home(".kilo", "skills")],
+    }),
+    notes: ["notes.opencode.hooks"],
+};
+// ------------------------------------------------------------------ Crush
+const CR = process.env.CRUSH_GLOBAL_CONFIG ?? home(".config", "crush");
+const crushFile = { user: () => path.join(CR, "crush.json"), project: (c) => (exists(path.join(c.root, ".crush.json")) ? path.join(c.root, ".crush.json") : path.join(c.root, "crush.json")) };
+export const crush = {
+    id: "crush",
+    name: "Crush",
+    bins: ["crush"],
+    dirs: [".config/crush"],
+    sections: [
+        mcpSection({ agent: "crush", files: crushFile, key: ["mcp"], disable: { type: "flag", key: "disabled", off: true } }),
+        listSection({
+            kind: "skills",
+            files: crushFile,
+            path: ["options", "disabled_skills"],
+            discover: (ctx) => [
+                ...skillsIn([home(".config", "agents", "skills"), path.join(CR, "skills"), home(".agents", "skills"), home(".claude", "skills")], t("group.user")),
+                ...skillsIn([".agents/skills", ".crush/skills", ".claude/skills", ".cursor/skills"].map((d) => path.join(ctx.root, d)), t("group.project")),
+            ],
+        }),
+        hooksSection({ agent: "crush", files: crushFile, key: ["hooks"] }),
+    ],
+    notes: ["notes.crush.format"],
+};
+// ------------------------------------------------------------------ Warp / Oz
+export const warp = {
+    id: "warp",
+    name: "Warp / Oz",
+    bins: ["oz", "warp"],
+    dirs: [],
+    sections: [],
+    notes: ["notes.warp.state", "notes.warp.none"],
+};

package/dist/agents/qwen.js

@@ -0,0 +1,46 @@
+import path from "node:path";
+import { dirSection, hooksSection, listSection } from "../core/generic.js";
+import { home, readJson } from "../core/jsonio.js";
+import { mcpGroup } from "../core/groups.js";
+import { t } from "../core/i18n.js";
+import { skillsIn } from "./_skills.js";
+const Q = home(".qwen");
+const settings = { user: () => path.join(Q, "settings.json"), project: (c) => path.join(c.root, ".qwen", "settings.json") };
+/** Command names (ns:cmd) of a commands directory. */
+function commands(dir, group) {
+    const s = dirSection({ kind: "commands", dirs: { user: () => dir }, entry: { ext: [".md", ".toml"] }, sep: ":" });
+    return s.list({ root: "" }, "user").filter((i) => i.enabled).map((i) => ({ id: i.label, group }));
+}
+export const qwen = {
+    id: "qwen",
+    name: "Qwen Code",
+    bins: ["qwen"],
+    dirs: [".qwen"],
+    sections: [
+        listSection({
+            kind: "mcp",
+            files: settings,
+            path: ["mcp", "excluded"],
+            discover: (ctx) => [settings.user(), settings.project(ctx)].flatMap((f, i) => Object.keys(readJson(f).mcpServers ?? {}).map((id) => ({ id, hint: t(i ? "hint.project" : "hint.user"), group: mcpGroup(id) }))),
+        }),
+        listSection({
+            kind: "skills",
+            files: settings,
+            path: ["skills", "disabled"],
+            discover: (ctx) => [
+                ...skillsIn([path.join(Q, "skills")], t("group.user")),
+                ...skillsIn([path.join(ctx.root, ".qwen", "skills")], t("group.project")),
+            ],
+            note: "note.qwenUnion",
+        }),
+        hooksSection({ agent: "qwen", files: settings, key: ["hooks"], disableAll: { path: ["disableAllHooks"], off: true } }),
+        listSection({
+            kind: "commands",
+            files: settings,
+            path: ["slashCommands", "disabled"],
+            discover: (ctx) => [...commands(path.join(Q, "commands"), t("group.user")), ...commands(path.join(ctx.root, ".qwen", "commands"), t("group.project"))],
+        }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(Q, "agents"), project: (c) => path.join(c.root, ".qwen", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.qwen.extensions"],
+};

package/dist/core/generic.js

@@ -0,0 +1,334 @@
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { editJson, exists, HOME, pathKey, state, getPath, isLink, listDir, moveEntry, readJson, toggled, toggleInList, writeText } from "./jsonio.js";
+import { sameEntry, stashed, updateStash } from "./stash.js";
+import { groupOrder, mcpGroup } from "./groups.js";
+import { t } from "./i18n.js";
+import { editYaml, readYaml } from "./yaml.js";
+export const JSON_IO = { read: (f) => readJson(f), edit: editJson };
+export const YAML_IO = { read: readYaml, edit: editYaml };
+const scopesOf = (f) => ["user", "project", "local"].filter((s) => f[s]);
+/** "User" or "Project" group label for a scope. */
+export const scopeGroup = (scope) => t(scope === "user" ? "group.user" : "group.project");
+/** Appends an optional translated note on a new line. */
+const withNote = (text, note) => (note ? `${text}\n${t(note)}` : text);
+export function shortPath(p) {
+    return pathKey(p).startsWith(pathKey(HOME)) ? "~" + p.slice(HOME.length).replace(/\\/g, "/") : p;
+}
+export function describeServer(def) {
+    if (!def || typeof def !== "object")
+        return "";
+    const url = def.url ?? def.httpUrl ?? def.serverUrl ?? def.uri;
+    if (url)
+        return String(url);
+    const cmd = Array.isArray(def.command) ? def.command : [def.command, ...(def.args ?? [])];
+    return cmd.filter(Boolean).join(" ").slice(0, 70);
+}
+export function sortByGroup(items, order = groupOrder()) {
+    return items.sort((a, b) => order.indexOf(a.group) - order.indexOf(b.group) || a.label.localeCompare(b.label));
+}
+// ------------------------------------------------------------------ JSON stash
+/** Removes a JSON object key and keeps it in the stash. */
+export function stashKey(agent, file, keyPath, label, io = JSON_IO) {
+    const value = getPath(io.read(file), keyPath);
+    if (value === undefined)
+        return;
+    updateStash(t("change.stashed", { what: label }), (s) => s.entries.push({ agent, file, kind: "keyed", path: keyPath, value }));
+    io.edit(file, t("change.removedFrom", { what: label, where: shortPath(file) }), [{ path: keyPath, value: undefined }]);
+}
+export function restoreKey(agent, file, keyPath, label, io = JSON_IO) {
+    const entry = stashed(agent, file).find((e) => e.kind === "keyed" && JSON.stringify(e.path) === JSON.stringify(keyPath));
+    if (!entry)
+        return;
+    io.edit(file, t("change.restoredIn", { what: label, where: shortPath(file) }), [{ path: keyPath, value: entry.value }]);
+    updateStash(t("change.unstashed", { what: label }), (s) => { s.entries = s.entries.filter((e) => !sameEntry(e, entry)); });
+}
+export function mcpSection(spec) {
+    const { agent, files, key, disable } = spec;
+    const io = spec.io ?? JSON_IO;
+    const isOff = (def, data, name) => disable.type === "flag" ? def?.[disable.key] === disable.off
+        : disable.type === "list" ? (getPath(data, disable.path) ?? []).includes(name)
+            : false;
+    return {
+        kind: "mcp",
+        scopes: scopesOf(files),
+        note: (scope, ctx) => `${shortPath(files[scope](ctx))} · ${spec.note ? t(spec.note) : describeDisable(disable)}`,
+        list(ctx, scope) {
+            const file = files[scope](ctx);
+            const data = io.read(file);
+            const items = Object.entries(getPath(data, key) ?? {}).map(([name, def]) => ({
+                id: name, label: name, hint: describeServer(def), group: mcpGroup(name), enabled: !isOff(def, data, name),
+            }));
+            for (const e of stashed(agent, file).filter((e) => e.kind === "keyed"))
+                items.push({ id: String(e.path.at(-1)), label: String(e.path.at(-1)), hint: `${describeServer(e.value)} · ${t("hint.stash")}`, group: mcpGroup(String(e.path.at(-1))), enabled: false });
+            return sortByGroup(items);
+        },
+        set(ctx, scope, item, enabled) {
+            const file = files[scope](ctx);
+            const label = `MCP ${item.id}`;
+            if (disable.type === "stash") {
+                if (enabled)
+                    restoreKey(agent, file, [...key, item.id], label, io);
+                else
+                    stashKey(agent, file, [...key, item.id], label, io);
+            }
+            else if (disable.type === "flag") {
+                io.edit(file, toggled(label, enabled, shortPath(file)), [
+                    // An "enabled" flag is set back to true (some agents require it); other flags are removed.
+                    { path: [...key, item.id, disable.key], value: enabled ? (disable.off === false ? true : undefined) : disable.off },
+                ]);
+            }
+            else {
+                const list = toggleInList(getPath(io.read(file), disable.path), item.id, !enabled);
+                io.edit(file, toggled(label, enabled, shortPath(file)), [{ path: disable.path, value: list.length ? list : undefined }]);
+            }
+        },
+    };
+}
+function describeDisable(d) {
+    return d.type === "flag" ? t("note.nativeFlag", { flag: `${d.key}: ${JSON.stringify(d.off)}` })
+        : d.type === "list" ? t("note.nativeList", { list: d.path.join(".") })
+            : t("note.noNativeStash");
+}
+const hookId = (event, group) => `${event}#${createHash("sha1").update(JSON.stringify(group)).digest("hex").slice(0, 10)}`;
+function describeHook(group) {
+    const hs = Array.isArray(group.hooks) ? group.hooks : [group];
+    const txt = `${group.matcher ? `[${group.matcher}] ` : ""}${hs.map((h) => h.command ?? h.bash ?? h.powershell ?? h.prompt ?? h.url ?? h.type ?? "?").join(" ; ")}`;
+    // Absolute paths are shortened to their file name to keep the list readable.
+    return txt.replace(/(?:[A-Za-z]:)?(?:[\\/][^\s"'\\/]+)+[\\/]([^\s"'\\/]+)/g, "…/$1").replace(/\s+/g, " ").slice(0, 90);
+}
+/**
+ * Hooks in the { event: [entries] } format (Claude, Gemini, Qwen, Cursor…).
+ * They can rarely be disabled one by one: the entry is removed and kept in the stash.
+ */
+export function hooksSection(spec) {
+    const { agent, files, key, disableAll } = spec;
+    const io = spec.io ?? JSON_IO;
+    const ALL = "__all__";
+    return {
+        kind: "hooks",
+        title: spec.title,
+        scopes: scopesOf(files),
+        note: (scope, ctx) => `${shortPath(files[scope](ctx))} · ${t("note.hookStash")}`,
+        list(ctx, scope) {
+            const file = files[scope](ctx);
+            const data = io.read(file);
+            const items = [];
+            if (disableAll)
+                items.push({ id: ALL, label: t("label.allHooks"), hint: disableAll.path.join("."), group: t("group.global"), enabled: getPath(data, disableAll.path) !== disableAll.off });
+            for (const [event, groups] of Object.entries(getPath(data, key) ?? {}))
+                if (Array.isArray(groups))
+                    for (const g of groups)
+                        items.push({ id: hookId(event, g), label: describeHook(g), group: event, enabled: true });
+            for (const e of stashed(agent, file).filter((e) => e.kind === "array")) {
+                const event = String(e.path.at(-1));
+                items.push({ id: hookId(event, e.value), label: describeHook(e.value), group: event, enabled: false });
+            }
+            return items;
+        },
+        set(ctx, scope, item, enabled) {
+            const file = files[scope](ctx);
+            if (item.id === ALL && disableAll) {
+                io.edit(file, toggled(t("label.allHooksShort"), enabled, shortPath(file)), [{ path: disableAll.path, value: enabled ? undefined : disableAll.off }]);
+                return;
+            }
+            const event = item.id.slice(0, item.id.lastIndexOf("#"));
+            const arrPath = [...key, event];
+            const current = getPath(io.read(file), arrPath) ?? [];
+            const label = `Hook ${event} ${item.label}`;
+            if (!enabled) {
+                const group = current.find((g) => hookId(event, g) === item.id);
+                if (!group)
+                    return;
+                updateStash(t("change.stashed", { what: `Hook ${event}` }), (s) => s.entries.push({ agent, file, kind: "array", path: arrPath, value: group }));
+                const rest = current.filter((g) => hookId(event, g) !== item.id);
+                io.edit(file, toggled(label, false), [{ path: arrPath, value: rest.length ? rest : undefined }]);
+            }
+            else {
+                const entry = stashed(agent, file).find((e) => e.kind === "array" && hookId(event, e.value) === item.id);
+                if (!entry)
+                    return;
+                io.edit(file, toggled(label, true), [{ path: arrPath, value: [...current, entry.value] }]);
+                updateStash(t("change.unstashed", { what: `Hook ${event}` }), (s) => { s.entries = s.entries.filter((e) => !sameEntry(e, entry)); });
+            }
+        },
+    };
+}
+function filesIn(dir, exts, rel = "") {
+    const out = [];
+    for (const d of listDir(path.join(dir, rel))) {
+        const r = rel ? `${rel}/${d.name}` : d.name;
+        if (d.isDirectory())
+            out.push(...filesIn(dir, exts, r));
+        else if (exts.some((e) => d.name.endsWith(e)))
+            out.push(r);
+    }
+    return out;
+}
+function entriesIn(dir, entry) {
+    if ("ext" in entry)
+        return filesIn(dir, entry.ext);
+    return listDir(dir)
+        .filter((d) => (d.isDirectory() || d.isSymbolicLink()) && !d.name.startsWith(".") && exists(path.join(dir, d.name, entry.dir)))
+        .map((d) => d.name);
+}
+/**
+ * Items stored as files/directories: a disabled item is moved from <dir>/
+ * to <dir>.disabled/, which the agent does not read.
+ */
+export function dirSection(spec) {
+    const label = (rel) => rel.replace(/\.[^./]+$/, "").replace(/\//g, spec.sep ?? "/");
+    return {
+        kind: spec.kind,
+        title: spec.title,
+        scopes: scopesOf(spec.dirs),
+        note: (scope, ctx) => withNote(`${shortPath(spec.dirs[scope](ctx))} · ${t("note.movedTo", { dir: `${path.basename(spec.dirs[scope](ctx))}.disabled/` })}`, spec.note),
+        list(ctx, scope) {
+            const on = spec.dirs[scope](ctx);
+            const group = scopeGroup(scope);
+            const hint = (d, r) => (isLink(path.join(d, r)) ? t("hint.link") : undefined);
+            return [
+                ...entriesIn(on, spec.entry).map((r) => ({ id: r, label: label(r), hint: hint(on, r), group, enabled: true })),
+                ...entriesIn(`${on}.disabled`, spec.entry).map((r) => ({ id: r, label: label(r), hint: hint(`${on}.disabled`, r), group, enabled: false })),
+            ].sort((a, b) => a.label.localeCompare(b.label));
+        },
+        set(ctx, scope, item, enabled) {
+            const on = spec.dirs[scope](ctx);
+            const off = `${on}.disabled`;
+            const [from, to] = enabled ? [off, on] : [on, off];
+            moveEntry(path.join(from, item.id), path.join(to, item.id), toggled(item.label, enabled, shortPath(on)));
+        },
+    };
+}
+/** Native switch through a list of names (e.g. skills.disabled). */
+export function listSection(spec) {
+    const allow = spec.mode === "allow";
+    const io = spec.io ?? JSON_IO;
+    return {
+        kind: spec.kind,
+        title: spec.title,
+        scopes: scopesOf(spec.files),
+        note: (scope, ctx) => withNote(`${shortPath(spec.files[scope](ctx))} · ${t("note.list", { list: spec.path.join(".") })}`, spec.note),
+        list(ctx, scope) {
+            const list = getPath(io.read(spec.files[scope](ctx)), spec.path) ?? [];
+            const seen = new Set();
+            const items = [];
+            for (const d of spec.discover(ctx, scope)) {
+                if (seen.has(d.id))
+                    continue;
+                seen.add(d.id);
+                items.push({ id: d.id, label: d.id, hint: d.hint, group: d.group ?? scopeGroup(scope), enabled: allow ? list.includes(d.id) : !list.includes(d.id) });
+            }
+            for (const n of list)
+                if (!seen.has(n))
+                    items.push({ id: n, label: n, hint: t("hint.notFound"), group: t("group.others"), enabled: allow });
+            return spec.kind === "mcp" ? sortByGroup(items) : items.sort((a, b) => a.group.localeCompare(b.group) || a.label.localeCompare(b.label));
+        },
+        set(ctx, scope, item, enabled) {
+            const file = spec.files[scope](ctx);
+            const list = toggleInList(getPath(io.read(file), spec.path), item.id, allow ? enabled : !enabled);
+            io.edit(file, toggled(item.id, enabled, shortPath(file)), [{ path: spec.path, value: list.length ? list : undefined }]);
+        },
+    };
+}
+export function dirNames(dir, marker) {
+    return listDir(dir)
+        .filter((d) => (d.isDirectory() || d.isSymbolicLink()) && !d.name.startsWith(".") && (!marker || fs.existsSync(path.join(dir, d.name, marker))))
+        .map((d) => d.name);
+}
+/** Scopes a scope inherits from, from the weakest to itself. */
+const inherits = (scope) => (scope === "local" ? ["user", "project", "local"] : scope === "project" ? ["user", "project"] : ["user"]);
+/** Native { id: boolean } switch with user → project → local inheritance. */
+export function boolMapSection(spec) {
+    const io = spec.io ?? JSON_IO;
+    const effective = (ctx, scope, id, dflt) => {
+        let v = dflt;
+        for (const s of inherits(scope)) {
+            const f = spec.files[s];
+            const x = f ? getPath(io.read(f(ctx)), [...spec.path, id]) : undefined;
+            if (typeof x === "boolean")
+                v = x;
+        }
+        return v;
+    };
+    return {
+        kind: spec.kind,
+        scopes: scopesOf(spec.files),
+        note: (scope, ctx) => withNote(`${shortPath(spec.files[scope](ctx))} · ${spec.path.join(".")}`, spec.note),
+        list(ctx, scope) {
+            const known = new Map(spec.discover(ctx).map((d) => [d.id, d]));
+            for (const s of inherits(scope)) {
+                const f = spec.files[s];
+                for (const id of Object.keys((f && getPath(io.read(f(ctx)), spec.path)) ?? {}))
+                    if (!known.has(id))
+                        known.set(id, { id, hint: t("hint.notInstalled"), enabled: false });
+            }
+            return [...known.values()]
+                .map((d) => ({ id: d.id, label: d.id, hint: d.hint, group: d.group ?? t("group.installed"), enabled: effective(ctx, scope, d.id, d.enabled) }))
+                .sort((a, b) => a.group.localeCompare(b.group) || a.label.localeCompare(b.label));
+        },
+        set(ctx, scope, item, enabled) {
+            const file = spec.files[scope](ctx);
+            io.edit(file, toggled(item.id, enabled, shortPath(file)), [{ path: [...spec.path, item.id], value: enabled }]);
+        },
+    };
+}
+// ------------------------------------------------------------------ agent CLI
+/** Runs the agent's own CLI (honours dry-run). */
+export function runAgentCli(bin, args, what, cwd) {
+    state.changes.push(what);
+    if (state.dryRun)
+        return;
+    const r = spawnSync(bin, args, { cwd, encoding: "utf8", shell: process.platform === "win32", timeout: 60_000 });
+    if (r.status !== 0)
+        throw new Error(`${bin} ${args.join(" ")}: ${(r.stderr || r.stdout || r.error?.message || t("err.failed")).trim().slice(0, 300)}`);
+}
+/** JSON output of an agent command, or undefined when unavailable. */
+export function agentCliJson(bin, args, cwd) {
+    const r = spawnSync(bin, args, { cwd, encoding: "utf8", shell: process.platform === "win32", timeout: 60_000 });
+    if (r.status !== 0)
+        return undefined;
+    try {
+        return JSON.parse(r.stdout);
+    }
+    catch {
+        return undefined;
+    }
+}
+// ------------------------------------------------------------------ SKILL.md frontmatter flag
+/** Reads/edits the "disabled: true" flag in the YAML frontmatter of a markdown file. */
+function frontmatterDisabled(text) {
+    const fm = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text)?.[1] ?? "";
+    return /^disabled:\s*true\s*$/m.test(fm) || /^enabled:\s*false\s*$/m.test(fm);
+}
+function setFrontmatterDisabled(text, disabled) {
+    const eol = text.includes("\r\n") ? "\r\n" : "\n";
+    const m = /^---\r?\n([\s\S]*?)\r?\n---/.exec(text);
+    const body = (m?.[1] ?? "").split(/\r?\n/).filter((l) => !/^(disabled|enabled):/.test(l) && (m || l));
+    if (disabled)
+        body.push("disabled: true");
+    const fm = body.filter((l, i) => l || i < body.length - 1).join(eol);
+    const rest = m ? text.slice(m[0].length) : `${eol}${text}`;
+    return fm ? `---${eol}${fm}${eol}---${rest}` : rest.replace(/^\r?\n/, "");
+}
+/** Skills disabled through their own frontmatter (e.g. Cline writes disabled: true). */
+export function frontmatterSkillsSection(spec) {
+    return {
+        kind: "skills",
+        scopes: scopesOf(spec.dirs),
+        note: (scope, ctx) => withNote(`${shortPath(spec.dirs[scope](ctx))} · SKILL.md → disabled: true`, spec.note),
+        list(ctx, scope) {
+            const dir = spec.dirs[scope](ctx);
+            return dirNames(dir, "SKILL.md").sort().map((n) => ({
+                id: n, label: n, group: scopeGroup(scope),
+                enabled: !frontmatterDisabled(fs.readFileSync(path.join(dir, n, "SKILL.md"), "utf8")),
+            }));
+        },
+        set(ctx, scope, item, enabled) {
+            const file = path.join(spec.dirs[scope](ctx), item.id, "SKILL.md");
+            writeText(file, setFrontmatterDisabled(fs.readFileSync(file, "utf8"), !enabled), toggled(`Skill ${item.id}`, enabled, shortPath(file)));
+        },
+    };
+}

package/dist/core/groups.js

@@ -0,0 +1,94 @@
+import fs from "node:fs";
+import path from "node:path";
+import { readJson, STATE_DIR } from "./jsonio.js";
+import { t } from "./i18n.js";
+export const groupsFile = path.join(STATE_DIR, "groups.json");
+/**
+ * Functional groups of MCP servers, keyed by a stable id (the display label
+ * comes from the translations). Each pattern is matched against the server's
+ * base name (without "claude.ai", "plugin:x:" or a "(2)" suffix), lowercased:
+ * substring, or a regular expression when wrapped in /.../.
+ * Order matters: the first matching group wins.
+ */
+export const DEFAULT_GROUPS = {
+    web: [
+        "jina", "scrapegraph", "brightdata", "bright data", "crawlbase", "firecrawl",
+        "tavily", "exa", "perplexity", "brave", "serper", "serpapi", "apify", "fetch",
+    ],
+    docs: ["context7", "deepwiki", "github", "gitlab", "sentry", "sourcegraph", "ref-tools", "engineering"],
+    browser: ["chrome", "devtools", "playwright", "puppeteer", "browser"],
+    data: [
+        "supabase", "cloudflare", "posthog", "postgres", "neon", "vercel", "firebase",
+        "mongo", "redis", "aws", "azure", "gcp", "bigquery", "snowflake", "/^data$/",
+    ],
+    apps: ["v0", "lovable", "replit", "bolt", "base44"],
+    design: ["figma", "canva", "magic patterns", "mobbin", "excalidraw", "superdesign", "framer", "/^design$/"],
+    media: ["higgsfield", "runway", "elevenlabs", "cloudinary", "splice", "wispr", "midjourney", "replicate", "fal"],
+    productivity: ["google drive", "google calendar", "notion", "claude docs", "gamma", "pdf", "productivity", "dropbox", "box"],
+    comms: ["gmail", "slack", "resend", "intercom", "discord", "teams", "outlook", "twilio"],
+    pm: ["linear", "asana", "atlassian", "jira", "monday", "clickup", "trello"],
+};
+export const OTHER_GROUP = "other";
+/** Display label of a group: translated for the default ids, as-is for custom groups. */
+export function groupLabel(id) {
+    return id in DEFAULT_GROUPS || id === OTHER_GROUP ? t(`group.${id}`) : id;
+}
+let cached;
+function config() {
+    if (cached)
+        return cached;
+    const user = readJson(groupsFile, {});
+    // User groups come first and replace default groups with the same id.
+    const groups = { ...(user.groups ?? {}) };
+    for (const [g, pats] of Object.entries(DEFAULT_GROUPS))
+        groups[g] ??= pats;
+    cached = { groups, overrides: user.overrides ?? {} };
+    return cached;
+}
+export function mcpBaseName(name) {
+    return name
+        .replace(/^claude\.ai /i, "")
+        .replace(/^plugin:[^:]+:/i, "")
+        .replace(/\s*\(\d+\)$/, "")
+        .replace(/^com\.|\/mcp$|-mcp$|-server$/gi, "")
+        .toLowerCase();
+}
+function matches(base, pattern) {
+    const p = pattern.toLowerCase();
+    if (p.length > 2 && p.startsWith("/") && p.endsWith("/"))
+        return new RegExp(p.slice(1, -1)).test(base);
+    // Short patterns (v0, exa, fal, box…): whole word only, to avoid false positives.
+    if (p.length <= 4)
+        return new RegExp(`(^|[^a-z0-9])${p.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}([^a-z0-9]|$)`).test(base);
+    return base.includes(p);
+}
+/** Group id of a server. */
+function groupId(name) {
+    const cfg = config();
+    if (cfg.overrides[name])
+        return cfg.overrides[name];
+    const base = mcpBaseName(name);
+    // For plugin servers, the plugin name is the fallback (e.g. plugin:design:figma → figma).
+    const plugin = /^plugin:([^:]+):/i.exec(name)?.[1]?.toLowerCase();
+    for (const cand of [base, plugin].filter(Boolean))
+        for (const [group, pats] of Object.entries(cfg.groups))
+            if (pats.some((p) => matches(cand, p)))
+                return group;
+    return OTHER_GROUP;
+}
+/** Display label of the group of a server. */
+export function mcpGroup(name) {
+    return groupLabel(groupId(name));
+}
+/** Group labels in display order. */
+export function groupOrder() {
+    return [...Object.keys(config().groups), OTHER_GROUP].map(groupLabel);
+}
+/** Writes an editable groups.json, pre-filled with the default groups. */
+export function initGroupsFile() {
+    if (!fs.existsSync(groupsFile)) {
+        fs.mkdirSync(path.dirname(groupsFile), { recursive: true });
+        fs.writeFileSync(groupsFile, JSON.stringify({ groups: DEFAULT_GROUPS, overrides: { "example-server": "other" } }, null, 2) + "\n");
+    }
+    return groupsFile;
+}