agentloom 0.1.0 → 0.1.2

package/dist/sync/index.js

@@ -1,49 +1,127 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { confirm, isCancel } from "@clack/prompts";
+import { cancel, isCancel, multiselect } from "@clack/prompts";
 import TOML from "@iarna/toml";
 import YAML from "yaml";
+import { ALL_PROVIDERS } from "../types.js";
 import { getProviderConfig, isProviderEnabled, parseAgentsDir, } from "../core/agents.js";
+import { parseCommandsDir } from "../core/commands.js";
 import { ensureDir, isObject, readJsonIfExists, relativePosix, removeFileIfExists, slugify, toPosixPath, writeJsonAtomic, writeTextAtomic, } from "../core/fs.js";
 import { readManifest, writeManifest } from "../core/manifest.js";
 import { readCanonicalMcp, resolveMcpForProvider } from "../core/mcp.js";
-import { getGlobalSettingsPath, readSettings, updateLastScope, } from "../core/settings.js";
+import { getGlobalSettingsPath, readSettings, updateLastScope, updateLastScopeBestEffort, } from "../core/settings.js";
+export async function resolveProvidersForSync(options) {
+    const settings = readSettings(options.paths.settingsPath);
+    return resolveProviders({
+        explicitProviders: options.explicitProviders,
+        settings,
+        nonInteractive: options.nonInteractive,
+    });
+}
 export async function syncFromCanonical(options) {
     const agents = parseAgentsDir(options.paths.agentsDir);
+    const commands = parseCommandsDir(options.paths.commandsDir);
     const mcp = readCanonicalMcp(options.paths);
     const manifest = readManifest(options.paths);
-    const settings = readSettings(options.paths.settingsPath);
-    const providers = resolveProviders(options.providers, settings);
+    const effectiveManifest = {
+        ...manifest,
+        generatedByEntity: normalizeGeneratedByEntity(manifest),
+    };
+    const providers = await resolveProvidersForSync({
+        paths: options.paths,
+        explicitProviders: options.providers,
+        nonInteractive: options.nonInteractive,
+    });
+    const target = options.target ?? "all";
     const nextManifest = {
         version: 1,
         generatedFiles: [],
+        generatedByEntity: {},
         codex: {
-            roles: [],
-            mcpServers: [],
+            roles: [...(effectiveManifest.codex?.roles ?? [])],
+            mcpServers: [...(effectiveManifest.codex?.mcpServers ?? [])],
         },
     };
-    const generated = new Set();
-    for (const provider of providers) {
-        syncProviderAgents({
-            provider,
+    const generatedAgents = new Set();
+    const generatedCommands = new Set();
+    const generatedMcp = new Set();
+    if (target === "all" || target === "agent") {
+        for (const provider of providers) {
+            syncProviderAgents({
+                provider,
+                paths: options.paths,
+                agents,
+                generated: generatedAgents,
+                dryRun: !!options.dryRun,
+            });
+        }
+    }
+    if (target === "all" || target === "command") {
+        for (const provider of providers) {
+            syncProviderCommands({
+                provider,
+                paths: options.paths,
+                commands,
+                generated: generatedCommands,
+                dryRun: !!options.dryRun,
+            });
+        }
+    }
+    if (target === "all" || target === "mcp") {
+        syncProviderMcp({
+            providers,
             paths: options.paths,
-            agents,
-            generated,
+            mcp,
+            generated: generatedMcp,
             dryRun: !!options.dryRun,
         });
     }
-    syncProviderMcp({
-        providers,
-        paths: options.paths,
-        agents,
-        mcp,
-        generated,
-        manifest,
-        nextManifest,
-        dryRun: !!options.dryRun,
-    });
-    nextManifest.generatedFiles = [...generated].sort();
+    if (providers.includes("codex")) {
+        const includeRoles = target === "all" || target === "agent";
+        const includeMcp = target === "all" || target === "mcp";
+        if (includeRoles || includeMcp) {
+            syncCodex({
+                paths: options.paths,
+                agents,
+                resolvedMcp: resolveMcpForProvider(mcp, "codex"),
+                generated: includeRoles ? generatedAgents : generatedMcp,
+                manifest: effectiveManifest,
+                nextManifest,
+                dryRun: !!options.dryRun,
+                includeRoles,
+                includeMcp,
+            });
+        }
+        else {
+            nextManifest.codex = {
+                roles: [...(effectiveManifest.codex?.roles ?? [])],
+                mcpServers: [...(effectiveManifest.codex?.mcpServers ?? [])],
+            };
+        }
+    }
+    const previousByEntity = normalizeGeneratedByEntity(effectiveManifest);
+    const nextByEntity = {
+        ...previousByEntity,
+    };
+    if (target === "all" || target === "agent") {
+        nextByEntity.agent = [...generatedAgents].sort();
+    }
+    if (target === "all" || target === "command") {
+        nextByEntity.command = [...generatedCommands].sort();
+    }
+    if (target === "all" || target === "mcp") {
+        nextByEntity.mcp = [...generatedMcp].sort();
+    }
+    nextManifest.generatedByEntity = pruneGeneratedByEntity(nextByEntity);
+    nextManifest.generatedFiles = [
+        ...new Set([
+            ...(nextManifest.generatedByEntity.agent ?? []),
+            ...(nextManifest.generatedByEntity.command ?? []),
+            ...(nextManifest.generatedByEntity.mcp ?? []),
+            ...(nextManifest.generatedByEntity.skill ?? []),
+        ]),
+    ].sort();
     const removedFiles = await removeStaleGeneratedFiles({
         oldManifest: manifest,
         newManifest: nextManifest,
@@ -54,7 +132,10 @@ export async function syncFromCanonical(options) {
     if (!options.dryRun) {
         writeManifest(options.paths, nextManifest);
         updateLastScope(options.paths.settingsPath, options.paths.scope, providers);
-        updateLastScope(getGlobalSettingsPath(options.paths.homeDir), options.paths.scope);
+        const globalSettingsPath = getGlobalSettingsPath(options.paths.homeDir);
+        if (options.paths.settingsPath !== globalSettingsPath) {
+            updateLastScopeBestEffort(globalSettingsPath, options.paths.scope, providers);
+        }
     }
     return {
         providers,
@@ -62,14 +143,56 @@ export async function syncFromCanonical(options) {
         removedFiles,
     };
 }
-function resolveProviders(explicitProviders, settings) {
-    if (explicitProviders && explicitProviders.length > 0) {
-        return [...new Set(explicitProviders)];
+const PROVIDER_LABELS = {
+    cursor: "Cursor",
+    claude: "Claude",
+    codex: "Codex",
+    opencode: "OpenCode",
+    gemini: "Gemini",
+    copilot: "Copilot",
+};
+const MULTISELECT_HELP_TEXT = "↑↓ move, space select, enter confirm";
+function withMultiselectHelp(message) {
+    return `${message}\n${MULTISELECT_HELP_TEXT}`;
+}
+async function resolveProviders(options) {
+    if (options.explicitProviders && options.explicitProviders.length > 0) {
+        return normalizeProviderSelection(options.explicitProviders);
     }
-    if (settings.defaultProviders && settings.defaultProviders.length > 0) {
-        return [...new Set(settings.defaultProviders)];
+    const defaults = normalizeProviderSelection(options.settings.defaultProviders);
+    const initialSelection = defaults.length > 0 ? defaults : [...ALL_PROVIDERS];
+    const nonInteractive = options.nonInteractive ?? !(process.stdin.isTTY && process.stdout.isTTY);
+    if (nonInteractive) {
+        return initialSelection;
     }
-    return ["cursor", "claude", "codex", "opencode", "gemini", "copilot"];
+    const selected = await multiselect({
+        message: withMultiselectHelp("Select providers to sync"),
+        options: ALL_PROVIDERS.map((provider) => ({
+            value: provider,
+            label: PROVIDER_LABELS[provider],
+        })),
+        initialValues: initialSelection,
+        required: true,
+    });
+    if (isCancel(selected)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    const normalized = normalizeProviderSelection(Array.isArray(selected) ? selected : []);
+    if (normalized.length === 0) {
+        throw new Error("At least one provider must be selected.");
+    }
+    return normalized;
+}
+function normalizeProviderSelection(providers) {
+    const selected = new Set();
+    for (const provider of providers ?? []) {
+        const normalized = provider.trim().toLowerCase();
+        if (ALL_PROVIDERS.includes(normalized)) {
+            selected.add(normalized);
+        }
+    }
+    return [...selected];
 }
 function syncProviderAgents(options) {
     const providerDir = getProviderAgentsDir(options.paths, options.provider);
@@ -84,9 +207,7 @@ function syncProviderAgents(options) {
         }
         const fileName = options.provider === "copilot"
             ? `${slugify(agent.name) || "agent"}.agent.md`
-            : options.provider === "cursor"
-                ? `${slugify(agent.name) || "agent"}.mdc`
-                : `${slugify(agent.name) || "agent"}.md`;
+            : `${slugify(agent.name) || "agent"}.md`;
         const outputPath = path.join(providerDir, fileName);
         const content = buildProviderAgentContent(options.provider, agent, providerConfig ?? {});
         if (!options.dryRun) {
@@ -97,15 +218,6 @@ function syncProviderAgents(options) {
     }
 }
 function buildProviderAgentContent(provider, agent, providerConfig) {
-    if (provider === "cursor") {
-        const frontmatter = {
-            description: agent.description,
-            alwaysApply: false,
-            ...providerConfig,
-        };
-        const fm = YAML.stringify(frontmatter).trimEnd();
-        return `---\n${fm}\n---\n\n${agent.body.trimStart()}${agent.body.endsWith("\n") ? "" : "\n"}`;
-    }
     const frontmatter = {
         name: agent.name,
         description: agent.description,
@@ -120,8 +232,8 @@ function getProviderAgentsDir(paths, provider) {
     switch (provider) {
         case "cursor":
             return paths.scope === "local"
-                ? path.join(workspaceRoot, ".cursor", "rules")
-                : path.join(home, ".cursor", "rules");
+                ? path.join(workspaceRoot, ".cursor", "agents")
+                : path.join(home, ".cursor", "agents");
         case "claude":
             return paths.scope === "local"
                 ? path.join(workspaceRoot, ".claude", "agents")
@@ -146,8 +258,74 @@ function getProviderAgentsDir(paths, provider) {
             return path.join(workspaceRoot, ".agents", "unknown");
     }
 }
+function syncProviderCommands(options) {
+    const providerDir = getProviderCommandsDir(options.paths, options.provider);
+    for (const command of options.commands) {
+        const fileName = mapProviderCommandFileName(options.provider, command.fileName);
+        const outputPath = path.join(providerDir, fileName);
+        if (!options.dryRun) {
+            ensureDir(path.dirname(outputPath));
+            writeTextAtomic(outputPath, command.content);
+        }
+        options.generated.add(outputPath);
+    }
+}
+function mapProviderCommandFileName(provider, fileName) {
+    const lower = fileName.toLowerCase();
+    if (provider === "copilot") {
+        if (lower.endsWith(".prompt.md"))
+            return fileName;
+        if (lower.endsWith(".md")) {
+            return `${fileName.slice(0, -3)}.prompt.md`;
+        }
+        if (lower.endsWith(".mdc")) {
+            return `${fileName.slice(0, -4)}.prompt.md`;
+        }
+        const ext = path.extname(fileName);
+        if (ext) {
+            return `${fileName.slice(0, -ext.length)}.prompt.md`;
+        }
+        return `${fileName}.prompt.md`;
+    }
+    if (lower.endsWith(".mdc")) {
+        return `${fileName.slice(0, -4)}.md`;
+    }
+    return fileName;
+}
+function getProviderCommandsDir(paths, provider) {
+    const workspaceRoot = paths.workspaceRoot;
+    const home = paths.homeDir;
+    switch (provider) {
+        case "cursor":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".cursor", "commands")
+                : path.join(home, ".cursor", "commands");
+        case "claude":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".claude", "commands")
+                : path.join(home, ".claude", "commands");
+        case "codex":
+            return path.join(home, ".codex", "prompts");
+        case "opencode":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".opencode", "commands")
+                : path.join(home, ".config", "opencode", "commands");
+        case "gemini":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".gemini", "commands")
+                : path.join(home, ".gemini", "commands");
+        case "copilot":
+            return paths.scope === "local"
+                ? path.join(workspaceRoot, ".github", "prompts")
+                : path.join(home, ".github", "prompts");
+        default:
+            return path.join(workspaceRoot, ".agents", "unknown", "commands");
+    }
+}
 function syncProviderMcp(options) {
     for (const provider of options.providers) {
+        if (provider === "codex")
+            continue;
         const resolved = resolveMcpForProvider(options.mcp, provider);
         if (provider === "cursor") {
             const outputPath = options.paths.scope === "local"
@@ -187,18 +365,6 @@ function syncProviderMcp(options) {
             options.generated.add(settingsPath);
             continue;
         }
-        if (provider === "codex") {
-            syncCodex({
-                paths: options.paths,
-                agents: options.agents,
-                resolvedMcp: resolved,
-                generated: options.generated,
-                manifest: options.manifest,
-                nextManifest: options.nextManifest,
-                dryRun: options.dryRun,
-            });
-            continue;
-        }
         if (provider === "opencode") {
             const outputPath = options.paths.scope === "local"
                 ? path.join(options.paths.workspaceRoot, ".opencode", "opencode.json")
@@ -310,63 +476,72 @@ function syncCodex(options) {
     features.multi_agent = true;
     parsed.features = features;
     const agentsTable = isObject(parsed.agents) ? { ...parsed.agents } : {};
-    const previousRoles = new Set(options.manifest.codex?.roles ?? []);
-    const nextRoles = [];
-    const enabledCodexRoles = new Set(options.agents
-        .filter((agent) => isProviderEnabled(agent.frontmatter, "codex"))
-        .map((agent) => slugify(agent.name))
-        .filter((role) => role.length > 0));
-    for (const oldRole of previousRoles) {
-        if (!enabledCodexRoles.has(oldRole)) {
-            delete agentsTable[oldRole];
-        }
-    }
-    for (const agent of options.agents) {
-        if (!isProviderEnabled(agent.frontmatter, "codex"))
-            continue;
-        const codexConfig = getProviderConfig(agent.frontmatter, "codex") ?? {};
-        const role = slugify(agent.name);
-        if (!role)
-            continue;
-        const roleTomlPath = path.join(codexAgentsDir, `${role}.toml`);
-        const roleInstructionsPath = path.join(codexAgentsDir, `${role}.instructions.md`);
-        const roleToml = buildCodexRoleToml(roleInstructionsPath, codexConfig);
-        if (!options.dryRun) {
-            ensureDir(codexAgentsDir);
-            writeTextAtomic(roleInstructionsPath, `${agent.body.trimStart()}\n`);
-            writeTextAtomic(roleTomlPath, TOML.stringify(roleToml));
-        }
-        options.generated.add(roleTomlPath);
-        options.generated.add(roleInstructionsPath);
-        agentsTable[role] = {
-            description: agent.description,
-            config_file: `./agents/${role}.toml`,
-        };
-        nextRoles.push(role);
-    }
-    parsed.agents = agentsTable;
-    const previousServers = new Set(options.manifest.codex?.mcpServers ?? []);
+    const trackedRoles = resolveTrackedCodexEntries(options.manifest.codex?.roles, Object.keys(agentsTable));
     const mcpServers = isObject(parsed.mcp_servers)
         ? { ...parsed.mcp_servers }
         : {};
-    for (const oldServer of previousServers) {
-        if (!Object.prototype.hasOwnProperty.call(options.resolvedMcp, oldServer)) {
-            delete mcpServers[oldServer];
+    const trackedServers = resolveTrackedCodexEntries(options.manifest.codex?.mcpServers, Object.keys(mcpServers));
+    let nextRoles = [...trackedRoles];
+    if (options.includeRoles) {
+        const previousRoles = new Set(trackedRoles);
+        nextRoles = [];
+        const enabledCodexRoles = new Set(options.agents
+            .filter((agent) => isProviderEnabled(agent.frontmatter, "codex"))
+            .map((agent) => slugify(agent.name))
+            .filter((role) => role.length > 0));
+        for (const oldRole of previousRoles) {
+            if (!enabledCodexRoles.has(oldRole)) {
+                delete agentsTable[oldRole];
+            }
+        }
+        for (const agent of options.agents) {
+            if (!isProviderEnabled(agent.frontmatter, "codex"))
+                continue;
+            const codexConfig = getProviderConfig(agent.frontmatter, "codex") ?? {};
+            const role = slugify(agent.name);
+            if (!role)
+                continue;
+            const roleTomlPath = path.join(codexAgentsDir, `${role}.toml`);
+            const roleInstructionsPath = path.join(codexAgentsDir, `${role}.instructions.md`);
+            const roleToml = buildCodexRoleToml(roleInstructionsPath, codexConfig);
+            if (!options.dryRun) {
+                ensureDir(codexAgentsDir);
+                writeTextAtomic(roleInstructionsPath, `${agent.body.trimStart()}\n`);
+                writeTextAtomic(roleTomlPath, TOML.stringify(roleToml));
+            }
+            options.generated.add(roleTomlPath);
+            options.generated.add(roleInstructionsPath);
+            agentsTable[role] = {
+                description: agent.description,
+                config_file: `./agents/${role}.toml`,
+            };
+            nextRoles.push(role);
+        }
+        parsed.agents = agentsTable;
+    }
+    let nextServers = [...trackedServers];
+    if (options.includeMcp) {
+        const previousServers = new Set(trackedServers);
+        for (const oldServer of previousServers) {
+            if (!Object.prototype.hasOwnProperty.call(options.resolvedMcp, oldServer)) {
+                delete mcpServers[oldServer];
+            }
         }
+        for (const [serverName, config] of Object.entries(options.resolvedMcp)) {
+            const mapped = {};
+            if (typeof config.url === "string")
+                mapped.url = config.url;
+            if (typeof config.command === "string")
+                mapped.command = config.command;
+            if (Array.isArray(config.args))
+                mapped.args = config.args;
+            if (isObject(config.env))
+                mapped.env = config.env;
+            mcpServers[serverName] = mapped;
+        }
+        parsed.mcp_servers = mcpServers;
+        nextServers = Object.keys(options.resolvedMcp).sort();
     }
-    for (const [serverName, config] of Object.entries(options.resolvedMcp)) {
-        const mapped = {};
-        if (typeof config.url === "string")
-            mapped.url = config.url;
-        if (typeof config.command === "string")
-            mapped.command = config.command;
-        if (Array.isArray(config.args))
-            mapped.args = config.args;
-        if (isObject(config.env))
-            mapped.env = config.env;
-        mcpServers[serverName] = mapped;
-    }
-    parsed.mcp_servers = mcpServers;
     if (!options.dryRun) {
         ensureDir(codexDir);
         writeTextAtomic(codexConfigPath, TOML.stringify(parsed));
@@ -374,9 +549,13 @@ function syncCodex(options) {
     options.generated.add(codexConfigPath);
     options.nextManifest.codex = {
         roles: nextRoles.sort(),
-        mcpServers: Object.keys(options.resolvedMcp).sort(),
+        mcpServers: nextServers.sort(),
     };
 }
+function resolveTrackedCodexEntries(trackedEntries, fallbackEntries) {
+    const tracked = Array.isArray(trackedEntries) ? trackedEntries : [];
+    return [...new Set([...tracked, ...fallbackEntries])].sort();
+}
 function buildCodexRoleToml(roleInstructionsPath, providerConfig) {
     const roleToml = {
         model_instructions_file: `./${path.basename(roleInstructionsPath)}`,
@@ -423,31 +602,34 @@ function maybeWriteJson(filePath, payload, dryRun) {
 async function removeStaleGeneratedFiles(options) {
     const oldSet = new Set(options.oldManifest.generatedFiles);
     const newSet = new Set(options.newManifest.generatedFiles);
-    const stale = [...oldSet].filter((filePath) => !newSet.has(filePath));
-    const removed = [];
-    for (const filePath of stale) {
-        if (!fs.existsSync(filePath))
-            continue;
-        if (options.dryRun) {
-            removed.push(filePath);
-            continue;
-        }
-        if (!options.yes && !options.nonInteractive) {
-            const shouldDelete = await confirm({
-                message: `Remove stale generated file ${toPosixPath(filePath)}?`,
-                initialValue: true,
-            });
-            if (isCancel(shouldDelete)) {
-                continue;
-            }
-            if (!shouldDelete) {
-                continue;
-            }
+    const stale = [...oldSet]
+        .filter((filePath) => !newSet.has(filePath))
+        .filter((filePath) => fs.existsSync(filePath));
+    if (stale.length === 0)
+        return [];
+    if (options.dryRun)
+        return stale;
+    if (!options.yes && !options.nonInteractive) {
+        const selected = await multiselect({
+            message: withMultiselectHelp("Remove stale generated files?"),
+            options: stale.map((filePath) => ({
+                value: filePath,
+                label: toPosixPath(filePath),
+            })),
+            initialValues: stale,
+        });
+        if (isCancel(selected))
+            return [];
+        const toRemove = Array.isArray(selected) ? selected : [];
+        for (const filePath of toRemove) {
+            removeFileIfExists(filePath);
         }
+        return toRemove;
+    }
+    for (const filePath of stale) {
         removeFileIfExists(filePath);
-        removed.push(filePath);
     }
-    return removed;
+    return stale;
 }
 function getVsCodeSettingsPath(homeDir) {
     switch (os.platform()) {
@@ -464,6 +646,88 @@ function getVsCodeSettingsPath(homeDir) {
             return path.join(homeDir, ".config", "Code", "User", "settings.json");
     }
 }
+function normalizeGeneratedByEntity(manifest) {
+    const source = manifest.generatedByEntity;
+    if (!source || typeof source !== "object") {
+        return inferGeneratedByEntityFromLegacyFiles(manifest.generatedFiles);
+    }
+    return {
+        agent: Array.isArray(source.agent) ? [...source.agent] : [],
+        command: Array.isArray(source.command) ? [...source.command] : [],
+        mcp: Array.isArray(source.mcp) ? [...source.mcp] : [],
+        skill: Array.isArray(source.skill) ? [...source.skill] : [],
+    };
+}
+function inferGeneratedByEntityFromLegacyFiles(generatedFiles) {
+    const byEntity = {
+        agent: [],
+        command: [],
+        mcp: [],
+        skill: [],
+    };
+    for (const filePath of generatedFiles) {
+        for (const entity of classifyLegacyGeneratedFile(filePath)) {
+            byEntity[entity]?.push(filePath);
+        }
+    }
+    return pruneGeneratedByEntity(byEntity);
+}
+function classifyLegacyGeneratedFile(filePath) {
+    const normalized = toPosixPath(filePath).toLowerCase();
+    if (isLegacyCodexConfigPath(normalized)) {
+        return ["agent", "mcp"];
+    }
+    if (isLegacyCommandOutputPath(normalized)) {
+        return ["command"];
+    }
+    if (isLegacyAgentOutputPath(normalized)) {
+        return ["agent"];
+    }
+    if (isLegacyMcpOutputPath(normalized)) {
+        return ["mcp"];
+    }
+    // Preserve unknown generated paths during scoped syncs.
+    return ["agent", "command", "mcp"];
+}
+function isLegacyCommandOutputPath(normalizedPath) {
+    return (normalizedPath.includes("/.cursor/commands/") ||
+        normalizedPath.includes("/.claude/commands/") ||
+        normalizedPath.includes("/.opencode/commands/") ||
+        normalizedPath.includes("/.gemini/commands/") ||
+        normalizedPath.includes("/.github/prompts/") ||
+        normalizedPath.includes("/.codex/prompts/"));
+}
+function isLegacyAgentOutputPath(normalizedPath) {
+    return (normalizedPath.includes("/.cursor/agents/") ||
+        normalizedPath.includes("/.cursor/rules/") ||
+        normalizedPath.includes("/.claude/agents/") ||
+        normalizedPath.includes("/.opencode/agents/") ||
+        normalizedPath.includes("/.gemini/agents/") ||
+        normalizedPath.includes("/.github/agents/") ||
+        normalizedPath.includes("/.codex/agents/"));
+}
+function isLegacyMcpOutputPath(normalizedPath) {
+    return (normalizedPath.endsWith("/.cursor/mcp.json") ||
+        normalizedPath.endsWith("/.mcp.json") ||
+        normalizedPath.endsWith("/.claude/settings.json") ||
+        normalizedPath.endsWith("/.opencode/opencode.json") ||
+        normalizedPath.endsWith("/.gemini/settings.json") ||
+        normalizedPath.endsWith("/.vscode/mcp.json") ||
+        normalizedPath.endsWith("/code/user/settings.json"));
+}
+function isLegacyCodexConfigPath(normalizedPath) {
+    return normalizedPath.endsWith("/.codex/config.toml");
+}
+function pruneGeneratedByEntity(value) {
+    const next = {};
+    for (const entity of ["agent", "command", "mcp", "skill"]) {
+        const files = value[entity];
+        if (!files || files.length === 0)
+            continue;
+        next[entity] = [...new Set(files)].sort();
+    }
+    return next;
+}
 export function formatSyncSummary(summary, agentsRoot) {
     const generated = summary.generatedFiles
         .map((filePath) => relativePosix(agentsRoot, filePath))