agent-toggle 0.1.0

package/dist/agents/more.js

@@ -0,0 +1,483 @@
+/*
+ * Agents that are usually not installed on the development machine: their
+ * adapters follow the official docs. When no native switch is documented, the
+ * safe fallback is used (stash for config entries, <dir>.disabled/ for files),
+ * because some agents reject unknown keys (Codebuff, Trae).
+ */
+import path from "node:path";
+import { boolMapSection, describeServer, dirNames, dirSection, frontmatterSkillsSection, hooksSection, listSection, mcpSection, shortPath, sortByGroup, YAML_IO } from "../core/generic.js";
+import { getPath, home, readJson, toggled } from "../core/jsonio.js";
+import { readToml, setArrayTableKey } from "../core/toml.js";
+import { tomlListSection } from "./_toml.js";
+import { skillsIn } from "./_skills.js";
+import { editYaml, readYaml } from "../core/yaml.js";
+import { sameEntry, stashed, updateStash } from "../core/stash.js";
+import { t } from "../core/i18n.js";
+import { mcpGroup } from "../core/groups.js";
+const appData = () => process.env.APPDATA ?? home("AppData", "Roaming");
+const xdgConfig = (...p) => process.platform === "win32" ? path.join(appData(), ...p) : path.join(process.env.XDG_CONFIG_HOME ?? home(".config"), ...p);
+// ------------------------------------------------------------------ JetBrains Junie
+const JUNIE = process.env.JUNIE_HOME ?? home(".junie");
+export const junie = {
+    id: "junie",
+    name: "JetBrains Junie CLI",
+    bins: ["junie"],
+    dirs: [".junie"],
+    sections: [
+        mcpSection({
+            agent: "junie",
+            files: { user: () => path.join(JUNIE, "mcp", "mcp.json"), project: (c) => path.join(c.root, ".junie", "mcp", "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "stash" },
+        }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(JUNIE, "skills"), project: (c) => path.join(c.root, ".junie", "skills") }, entry: { dir: "SKILL.md" } }),
+        hooksSection({ agent: "junie", files: { user: () => path.join(JUNIE, "config.json") }, key: ["hooks"] }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(JUNIE, "commands"), project: (c) => path.join(c.root, ".junie", "commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(JUNIE, "agents"), project: (c) => path.join(c.root, ".junie", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.junie.native"],
+};
+// ------------------------------------------------------------------ Amazon Q Developer CLI (legacy of Kiro CLI)
+export const amazonq = {
+    id: "amazonq",
+    name: "Amazon Q Developer CLI",
+    bins: ["qchat"],
+    dirs: [".aws/amazonq"],
+    sections: [
+        mcpSection({
+            agent: "amazonq",
+            files: { user: () => home(".aws", "amazonq", "mcp.json"), project: (c) => path.join(c.root, ".amazonq", "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+        }),
+        dirSection({ kind: "commands", title: "title.kiroPrompts", dirs: { user: () => home(".aws", "amazonq", "prompts"), project: (c) => path.join(c.root, ".amazonq", "prompts") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => home(".aws", "amazonq", "cli-agents"), project: (c) => path.join(c.root, ".amazonq", "cli-agents") }, entry: { ext: [".json"] } }),
+    ],
+    notes: ["notes.amazonq.legacy"],
+};
+// ------------------------------------------------------------------ Letta Code
+const LETTA = home(".letta");
+export const letta = {
+    id: "letta",
+    name: "Letta Code",
+    bins: ["letta"],
+    dirs: [".letta"],
+    sections: [
+        hooksSection({
+            agent: "letta",
+            files: {
+                user: () => path.join(LETTA, "settings.json"),
+                project: (c) => path.join(c.root, ".letta", "settings.json"),
+                local: (c) => path.join(c.root, ".letta", "settings.local.json"),
+            },
+            key: ["hooks"],
+            disableAll: { path: ["hooks", "disabled"], off: true },
+        }),
+        dirSection({ kind: "plugins", title: "title.mods", dirs: { user: () => path.join(LETTA, "mods") }, entry: { ext: [".ts", ".js"] } }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(LETTA, "skills"), project: (c) => path.join(c.root, ".agents", "skills") }, entry: { dir: "SKILL.md" }, note: "note.sharedSkillsMoved" }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(LETTA, "commands"), project: (c) => path.join(c.root, ".commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(LETTA, "agents"), project: (c) => path.join(c.root, ".letta", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.letta.mcp"],
+};
+// ------------------------------------------------------------------ Pi coding agent
+const PI = process.env.PI_CODING_AGENT_DIR ?? home(".pi", "agent");
+export const pi = {
+    id: "pi",
+    name: "Pi coding agent",
+    bins: [],
+    dirs: [".pi/agent"],
+    sections: [
+        dirSection({ kind: "plugins", title: "title.extensions", dirs: { user: () => path.join(PI, "extensions"), project: (c) => path.join(c.root, ".pi", "extensions") }, entry: { ext: [".ts", ".js"] } }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(PI, "skills"), project: (c) => path.join(c.root, ".pi", "skills") }, entry: { dir: "SKILL.md" } }),
+        dirSection({ kind: "commands", title: "title.promptTemplates", dirs: { user: () => path.join(PI, "prompts"), project: (c) => path.join(c.root, ".pi", "prompts") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.pi.noMcp"],
+};
+// ------------------------------------------------------------------ Codebuff / Freebuff
+export const codebuff = {
+    id: "codebuff",
+    name: "Codebuff",
+    bins: ["codebuff", "freebuff"],
+    dirs: [".config/manicode"],
+    sections: [
+        mcpSection({
+            agent: "codebuff",
+            files: { user: () => home(".agents", "mcp.json"), project: (c) => path.join(c.root, ".agents", "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "stash" },
+            note: "note.strictSchema",
+        }),
+    ],
+};
+// ------------------------------------------------------------------ Trae Agent
+export const trae = {
+    id: "trae",
+    name: "Trae Agent",
+    bins: ["trae-cli"],
+    dirs: [],
+    sections: [
+        listSection({
+            kind: "mcp",
+            files: { project: (c) => path.join(c.root, "trae_config.yaml") },
+            path: ["allow_mcp_servers"],
+            mode: "allow",
+            io: YAML_IO,
+            discover: (ctx) => Object.keys(readYaml(path.join(ctx.root, "trae_config.yaml")).mcp_servers ?? {}).map((id) => ({ id, group: mcpGroup(id) })),
+            note: "note.traeAllow",
+        }),
+    ],
+};
+// ------------------------------------------------------------------ Windsurf (Devin Desktop)
+export const windsurf = {
+    id: "windsurf",
+    name: "Windsurf",
+    bins: ["windsurf"],
+    dirs: [".codeium/windsurf"],
+    sections: [
+        mcpSection({
+            agent: "windsurf",
+            files: { user: () => home(".codeium", "windsurf", "mcp_config.json") },
+            key: ["mcpServers"],
+            disable: { type: "stash" },
+        }),
+    ],
+    notes: ["notes.windsurf.devin"],
+};
+// ------------------------------------------------------------------ Hermes Agent
+const HERMES = home(".hermes");
+export const hermes = {
+    id: "hermes",
+    name: "Hermes Agent",
+    bins: ["hermes"],
+    dirs: [".hermes"],
+    sections: [
+        mcpSection({
+            agent: "hermes",
+            files: { user: () => path.join(HERMES, "config.yaml") },
+            key: ["mcp_servers"],
+            disable: { type: "flag", key: "enabled", off: false },
+            io: YAML_IO,
+        }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(HERMES, "skills") }, entry: { dir: "SKILL.md" } }),
+    ],
+};
+// ------------------------------------------------------------------ Qoder CLI
+const QODER = home(".qoder");
+const qoderSettings = {
+    user: () => path.join(QODER, "settings.json"),
+    project: (c) => path.join(c.root, ".qoder", "settings.json"),
+    local: (c) => path.join(c.root, ".qoder", "settings.local.json"),
+};
+export const qoder = {
+    id: "qoder",
+    name: "Qoder CLI",
+    bins: ["qodercli", "qoder"],
+    dirs: [".qoder"],
+    sections: [
+        mcpSection({ agent: "qoder", files: qoderSettings, key: ["mcpServers"], disable: { type: "stash" } }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(QODER, "skills"), project: (c) => path.join(c.root, ".qoder", "skills") }, entry: { dir: "SKILL.md" } }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(QODER, "commands"), project: (c) => path.join(c.root, ".qoder", "commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(QODER, "agents"), project: (c) => path.join(c.root, ".qoder", "agents") }, entry: { ext: [".md"] } }),
+    ],
+};
+// ------------------------------------------------------------------ CodeBuddy Code (Tencent)
+const CB = process.env.CODEBUDDY_CONFIG_DIR ?? home(".codebuddy");
+const cbSettings = {
+    user: () => path.join(CB, "settings.json"),
+    project: (c) => path.join(c.root, ".codebuddy", "settings.json"),
+    local: (c) => path.join(c.root, ".codebuddy", "settings.local.json"),
+};
+export const codebuddy = {
+    id: "codebuddy",
+    name: "CodeBuddy Code",
+    bins: ["codebuddy"],
+    dirs: [".codebuddy"],
+    sections: [
+        mcpSection({ agent: "codebuddy", files: { user: () => path.join(CB, ".mcp.json"), project: (c) => path.join(c.root, ".mcp.json") }, key: ["mcpServers"], disable: { type: "stash" } }),
+        boolMapSection({ kind: "plugins", files: cbSettings, path: ["enabledPlugins"], discover: () => [] }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(CB, "skills"), project: (c) => path.join(c.root, ".codebuddy", "skills") }, entry: { dir: "SKILL.md" } }),
+        hooksSection({ agent: "codebuddy", files: cbSettings, key: ["hooks"] }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(CB, "commands"), project: (c) => path.join(c.root, ".codebuddy", "commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(CB, "agents"), project: (c) => path.join(c.root, ".codebuddy", "agents") }, entry: { ext: [".md"] } }),
+    ],
+};
+// ------------------------------------------------------------------ Command Code
+export const commandcode = {
+    id: "commandcode",
+    name: "Command Code",
+    bins: ["commandcode", "cmd-code"],
+    dirs: [".commandcode"],
+    sections: [
+        mcpSection({ agent: "commandcode", files: { user: () => home(".commandcode", "mcp.json") }, key: ["mcpServers"], disable: { type: "stash" } }),
+        hooksSection({ agent: "commandcode", files: { user: () => home(".commandcode", "settings.json") }, key: ["hooks"] }),
+    ],
+};
+// ------------------------------------------------------------------ detected, nothing to toggle
+export const aider = { id: "aider", name: "Aider", bins: ["aider"], dirs: [], sections: [], notes: ["notes.aider.none"] };
+export const plandex = { id: "plandex", name: "Plandex", bins: ["plandex", "pdx"], dirs: [".plandex-home-v2"], sections: [], notes: ["notes.plandex.none"] };
+// ------------------------------------------------------------------ Goose
+/** Goose keeps its YAML config under %APPDATA%\Block\goose\config on Windows. */
+const GOOSE = process.env.GOOSE_PATH_ROOT
+    ? path.join(process.env.GOOSE_PATH_ROOT, "config")
+    : process.platform === "win32" ? path.join(appData(), "Block", "goose", "config") : xdgConfig("goose");
+const gooseSettings = {
+    user: () => (process.env.GOOSE_PATH_ROOT ? path.join(process.env.GOOSE_PATH_ROOT, ".config", "goose", "settings.json") : home(".config", "goose", "settings.json")),
+    project: (c) => path.join(c.root, ".config", "goose", "settings.json"),
+    local: (c) => path.join(c.root, ".config", "goose", "settings.local.json"),
+};
+export const goose = {
+    id: "goose",
+    name: "Goose",
+    bins: ["goose"],
+    dirs: [],
+    sections: [
+        mcpSection({
+            agent: "goose",
+            files: { user: () => path.join(GOOSE, "config.yaml") },
+            key: ["extensions"],
+            disable: { type: "flag", key: "enabled", off: false },
+            io: YAML_IO,
+        }),
+        listSection({
+            kind: "plugins",
+            files: gooseSettings,
+            path: ["disabledPlugins"],
+            discover: (ctx, scope) => dirNames(scope === "user" ? home(".agents", "plugins") : path.join(ctx.root, ".agents", "plugins")).map((id) => ({ id })),
+        }),
+    ],
+    notes: ["notes.goose.plugins"],
+};
+// ------------------------------------------------------------------ Cline CLI
+const CLINE = process.env.CLINE_DIR ?? home(".cline");
+export const cline = {
+    id: "cline",
+    name: "Cline CLI",
+    bins: ["cline"],
+    dirs: [".cline"],
+    sections: [
+        mcpSection({
+            agent: "cline",
+            files: { user: () => process.env.CLINE_MCP_SETTINGS_PATH ?? path.join(CLINE, "data", "settings", "cline_mcp_settings.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "disabled", off: true },
+        }),
+        frontmatterSkillsSection({ dirs: { user: () => path.join(CLINE, "skills"), project: (c) => path.join(c.root, ".cline", "skills") } }),
+        dirSection({ kind: "hooks", title: "title.hookFiles", dirs: { user: () => path.join(CLINE, "hooks"), project: (c) => path.join(c.root, ".cline", "hooks") }, entry: { ext: [".sh", ".js", ".ts", ".ps1"] } }),
+        dirSection({ kind: "commands", title: "title.workflows", dirs: { user: () => path.join(CLINE, "workflows"), project: (c) => path.join(c.root, ".cline", "workflows") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(CLINE, "agents"), project: (c) => path.join(c.root, ".cline", "agents") }, entry: { ext: [".md"] } }),
+    ],
+};
+// ------------------------------------------------------------------ Continue CLI
+const CONTINUE = process.env.CONTINUE_GLOBAL_DIR ?? home(".continue");
+const continueYaml = () => path.join(CONTINUE, "config.yaml");
+/**
+ * Continue lists its MCP servers as a YAML array (mcpServers: [{ name, … }])
+ * without any enabled flag: a disabled server is taken out of the array and
+ * kept in the stash, then appended back.
+ */
+const continueMcp = {
+    kind: "mcp",
+    scopes: ["user"],
+    note: () => `${shortPath(continueYaml())} · ${t("note.noNativeStash")}`,
+    list() {
+        const file = continueYaml();
+        const items = (getPath(readYaml(file), ["mcpServers"]) ?? []).map((d) => ({
+            id: String(d.name), label: String(d.name), hint: describeServer(d), group: mcpGroup(String(d.name)), enabled: true,
+        }));
+        for (const e of stashed("continue", file))
+            items.push({ id: String(e.value.name), label: String(e.value.name), hint: `${describeServer(e.value)} · ${t("hint.stash")}`, group: mcpGroup(String(e.value.name)), enabled: false });
+        return sortByGroup(items);
+    },
+    set(_ctx, _scope, item, enabled) {
+        const file = continueYaml();
+        const list = getPath(readYaml(file), ["mcpServers"]) ?? [];
+        const label = `MCP ${item.id}`;
+        if (!enabled) {
+            const def = list.find((d) => String(d.name) === item.id);
+            if (!def)
+                return;
+            updateStash(t("change.stashed", { what: label }), (s) => s.entries.push({ agent: "continue", file, kind: "array", path: ["mcpServers"], value: def }));
+            const rest = list.filter((d) => String(d.name) !== item.id);
+            editYaml(file, toggled(label, false, shortPath(file)), [{ path: ["mcpServers"], value: rest.length ? rest : undefined }]);
+        }
+        else {
+            const entry = stashed("continue", file).find((e) => String(e.value.name) === item.id);
+            if (!entry)
+                return;
+            editYaml(file, toggled(label, true, shortPath(file)), [{ path: ["mcpServers"], value: [...list, entry.value] }]);
+            updateStash(t("change.unstashed", { what: label }), (s) => { s.entries = s.entries.filter((e) => !sameEntry(e, entry)); });
+        }
+    },
+};
+export const continueCli = {
+    id: "continue",
+    name: "Continue CLI",
+    bins: ["cn"],
+    dirs: [".continue"],
+    sections: [
+        continueMcp,
+        dirSection({ kind: "skills", dirs: { user: () => path.join(CONTINUE, "skills"), project: (c) => path.join(c.root, ".continue", "skills") }, entry: { dir: "SKILL.md" } }),
+        hooksSection({
+            agent: "continue",
+            files: {
+                user: () => path.join(CONTINUE, "settings.json"),
+                project: (c) => path.join(c.root, ".continue", "settings.json"),
+                local: (c) => path.join(c.root, ".continue", "settings.local.json"),
+            },
+            key: ["hooks"],
+            disableAll: { path: ["disableAllHooks"], off: true },
+        }),
+    ],
+    notes: ["notes.continue.maintenance"],
+};
+// ------------------------------------------------------------------ Augment Auggie CLI
+const AUG = home(".augment");
+const augSettings = {
+    user: () => path.join(AUG, "settings.json"),
+    project: (c) => path.join(c.root, ".augment", "settings.json"),
+    local: (c) => path.join(c.root, ".augment", "settings.local.json"),
+};
+export const auggie = {
+    id: "auggie",
+    name: "Augment Auggie CLI",
+    bins: ["auggie"],
+    dirs: [".augment"],
+    sections: [
+        mcpSection({ agent: "auggie", files: augSettings, key: ["mcpServers"], disable: { type: "stash" } }),
+        boolMapSection({ kind: "plugins", files: augSettings, path: ["enabledPlugins"], discover: () => [] }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(AUG, "skills"), project: (c) => path.join(c.root, ".augment", "skills") }, entry: { dir: "SKILL.md" } }),
+        hooksSection({ agent: "auggie", files: augSettings, key: ["hooks"] }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(AUG, "commands"), project: (c) => path.join(c.root, ".augment", "commands") }, entry: { ext: [".md"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(AUG, "agents"), project: (c) => path.join(c.root, ".augment", "agents") }, entry: { ext: [".md"] } }),
+    ],
+};
+// ------------------------------------------------------------------ OpenHands CLI
+const OH = process.env.OPENHANDS_PERSISTENCE_DIR ?? home(".openhands");
+export const openhands = {
+    id: "openhands",
+    name: "OpenHands CLI",
+    bins: ["openhands"],
+    dirs: [".openhands"],
+    sections: [
+        mcpSection({
+            agent: "openhands",
+            files: { user: () => path.join(OH, "mcp.json") },
+            key: ["mcpServers"],
+            disable: { type: "flag", key: "enabled", off: false },
+        }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(OH, "skills"), project: (c) => path.join(c.root, ".openhands", "skills") }, entry: { dir: "SKILL.md" } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(OH, "agents"), project: (c) => path.join(c.root, ".openhands", "agents") }, entry: { ext: [".md"] } }),
+    ],
+};
+// ------------------------------------------------------------------ Kimi CLI
+const KIMI = process.env.KIMI_SHARE_DIR ?? home(".kimi");
+export const kimi = {
+    id: "kimi",
+    name: "Kimi CLI",
+    bins: ["kimi", "kimi-cli"],
+    dirs: [".kimi"],
+    sections: [
+        mcpSection({ agent: "kimi", files: { user: () => path.join(KIMI, "mcp.json") }, key: ["mcpServers"], disable: { type: "stash" } }),
+        dirSection({ kind: "plugins", dirs: { user: () => path.join(KIMI, "plugins") }, entry: { dir: "plugin.json" } }),
+        dirSection({ kind: "skills", dirs: { user: () => home(".kimi", "skills"), project: (c) => path.join(c.root, ".kimi", "skills") }, entry: { dir: "SKILL.md" } }),
+    ],
+};
+// ------------------------------------------------------------------ Mistral Vibe
+const VIBE = process.env.VIBE_HOME ?? home(".vibe");
+const vibeConfig = { user: () => path.join(VIBE, "config.toml"), project: (c) => path.join(c.root, ".vibe", "config.toml") };
+const vibeFor = (scope, ctx) => (scope === "user" ? vibeConfig.user() : vibeConfig.project(ctx));
+/** MCP: [[mcp_servers]] blocks identified by name, with a native disabled = true. */
+const vibeMcp = {
+    kind: "mcp",
+    scopes: ["user", "project"],
+    note: (s, c) => `${shortPath(vibeFor(s, c))} · [[mcp_servers]] disabled = true`,
+    list(ctx, scope) {
+        const servers = readToml(vibeFor(scope, ctx)).mcp_servers ?? [];
+        return sortByGroup(servers.filter((d) => d?.name).map((d) => ({
+            id: String(d.name), label: String(d.name), hint: describeServer(d), group: mcpGroup(String(d.name)), enabled: d.disabled !== true,
+        })));
+    },
+    set(ctx, scope, item, enabled) {
+        const file = vibeFor(scope, ctx);
+        setArrayTableKey(file, ["mcp_servers"], (d) => String(d.name) === item.id, "disabled", enabled ? undefined : true, toggled(`MCP ${item.id}`, enabled, shortPath(file)));
+    },
+};
+export const vibe = {
+    id: "vibe",
+    name: "Mistral Vibe",
+    bins: ["vibe"],
+    dirs: [".vibe"],
+    sections: [
+        vibeMcp,
+        tomlListSection({
+            kind: "skills",
+            files: vibeConfig,
+            table: [],
+            key: "disabled_skills",
+            discover: (ctx, scope) => scope === "user"
+                ? skillsIn([path.join(VIBE, "skills"), home(".agents", "skills")], t("group.user"))
+                : skillsIn([path.join(ctx.root, ".vibe", "skills"), path.join(ctx.root, ".agents", "skills")], t("group.project")),
+        }),
+        tomlListSection({
+            kind: "agents",
+            files: vibeConfig,
+            table: [],
+            key: "disabled_agents",
+            discover: (ctx, scope) => dirSection({ kind: "agents", dirs: { user: () => (scope === "user" ? path.join(VIBE, "agents") : path.join(ctx.root, ".vibe", "agents")) }, entry: { ext: [".toml"] } })
+                .list(ctx, "user").map((i) => ({ id: i.label })),
+        }),
+    ],
+    notes: ["notes.vibe.trust"],
+};
+// ------------------------------------------------------------------ iFlow CLI (discontinued)
+const IFLOW = process.env.IFLOW_HOME ?? home(".iflow");
+const iflowSettings = { user: () => path.join(IFLOW, "settings.json"), project: (c) => path.join(c.root, ".iflow", "settings.json") };
+export const iflow = {
+    id: "iflow",
+    name: "iFlow CLI",
+    bins: ["iflow"],
+    dirs: [".iflow"],
+    sections: [
+        listSection({
+            kind: "mcp",
+            files: iflowSettings,
+            path: ["excludeMCPServers"],
+            discover: (ctx) => [iflowSettings.user(), iflowSettings.project(ctx)].flatMap((f) => Object.keys(readJson(f).mcpServers ?? {}).map((id) => ({ id, group: mcpGroup(id) }))),
+        }),
+        hooksSection({ agent: "iflow", files: iflowSettings, key: ["hooks"] }),
+        dirSection({ kind: "commands", dirs: { user: () => path.join(IFLOW, "commands"), project: (c) => path.join(c.root, ".iflow", "commands") }, entry: { ext: [".md", ".toml"] } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(IFLOW, "agents"), project: (c) => path.join(c.root, ".iflow", "agents") }, entry: { ext: [".md"] } }),
+    ],
+    notes: ["notes.iflow.discontinued"],
+};
+// ------------------------------------------------------------------ Qodo Command (deprecated)
+export const qodo = {
+    id: "qodo",
+    name: "Qodo Command",
+    bins: ["qodo"],
+    dirs: [".qodo"],
+    sections: [
+        mcpSection({ agent: "qodo", files: { project: (c) => path.join(c.root, "mcp.json") }, key: ["mcpServers"], disable: { type: "stash" } }),
+    ],
+    notes: ["notes.qodo.deprecated"],
+};
+// ------------------------------------------------------------------ Rovo Dev CLI (Atlassian)
+const ROVO = home(".rovodev");
+export const rovodev = {
+    id: "rovodev",
+    name: "Rovo Dev CLI",
+    bins: [],
+    dirs: [".rovodev"],
+    sections: [
+        listSection({
+            kind: "mcp",
+            files: { user: () => path.join(ROVO, "config.yml") },
+            path: ["mcp", "disabledMcpServers"],
+            io: YAML_IO,
+            discover: () => ["mcp.json", "mcp_config.json"].flatMap((f) => Object.keys(readJson(path.join(ROVO, f)).mcpServers ?? {}).map((id) => ({ id, group: mcpGroup(id) }))),
+        }),
+        dirSection({ kind: "skills", dirs: { user: () => path.join(ROVO, "skills"), project: (c) => path.join(c.root, ".rovodev", "skills") }, entry: { dir: "SKILL.md" } }),
+        dirSection({ kind: "agents", dirs: { user: () => path.join(ROVO, "subagents"), project: (c) => path.join(c.root, ".rovodev", "subagents") }, entry: { ext: [".md"] } }),
+    ],
+};