agentloom 0.1.5 → 0.1.7

package/dist/sync/index.js

@@ -5,11 +5,12 @@ 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 { parseCommandsDir, renderCommandForProvider, } from "../core/commands.js";
+import { parseRulesDir, renderRuleForCursor, upsertManagedRuleBlocks, } from "../core/rules.js";
+import { ensureDir, isObject, readJsonIfExists, readTextIfExists, 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 { getClaudeMcpPath, getClaudeSettingsPath, getCodexAgentsDir, getCodexConfigPath, getCodexRootDir, getCopilotMcpPath, getCursorMcpPath, getGeminiSettingsPath, getOpenCodeConfigPath, getPiMcpPath, getProviderAgentsDir, getProviderCommandsDir, getVsCodeSettingsPath, } from "../core/provider-paths.js";
+import { getClaudeMcpPath, getClaudeSettingsPath, getCodexAgentsDir, getCodexConfigPath, getCodexRootDir, getCopilotMcpPath, getCursorRulesDir, getCursorMcpPath, getGeminiSettingsPath, getOpenCodeConfigPath, getPiMcpPath, getProviderAgentsDir, getProviderCommandsDir, getRuleInstructionPaths, getVsCodeSettingsPath, } from "../core/provider-paths.js";
 import { getGlobalSettingsPath, readSettings, updateLastScope, updateLastScopeBestEffort, } from "../core/settings.js";
 export async function resolveProvidersForSync(options) {
     const settings = readSettings(options.paths.settingsPath);
@@ -22,6 +23,8 @@ export async function resolveProvidersForSync(options) {
 export async function syncFromCanonical(options) {
     const agents = parseAgentsDir(options.paths.agentsDir);
     const commands = parseCommandsDir(options.paths.commandsDir);
+    const rules = parseRulesDir(options.paths.rulesDir);
+    const managedInstructionRules = rules.filter((rule) => rule.frontmatter.alwaysApply !== false);
     const mcp = readCanonicalMcp(options.paths);
     const manifest = readManifest(options.paths);
     const effectiveManifest = {
@@ -46,6 +49,9 @@ export async function syncFromCanonical(options) {
     const generatedAgents = new Set();
     const generatedCommands = new Set();
     const generatedMcp = new Set();
+    const generatedRules = new Set();
+    const updatedRuleInstructionFiles = new Set();
+    const retainedRuleInstructionFiles = new Set();
     if (target === "all" || target === "agent") {
         for (const provider of providers) {
             syncProviderAgents({
@@ -56,6 +62,13 @@ export async function syncFromCanonical(options) {
                 dryRun: !!options.dryRun,
             });
         }
+        if (providers.includes("copilot") && options.paths.scope === "global") {
+            syncCopilotDiscoverySettings({
+                paths: options.paths,
+                dryRun: !!options.dryRun,
+                includeAgentLocations: true,
+            });
+        }
     }
     if (target === "all" || target === "command") {
         for (const provider of providers) {
@@ -67,6 +80,13 @@ export async function syncFromCanonical(options) {
                 dryRun: !!options.dryRun,
             });
         }
+        if (providers.includes("copilot") && options.paths.scope === "global") {
+            syncCopilotDiscoverySettings({
+                paths: options.paths,
+                dryRun: !!options.dryRun,
+                includePromptLocations: true,
+            });
+        }
     }
     if (target === "all" || target === "mcp") {
         syncProviderMcp({
@@ -77,6 +97,33 @@ export async function syncFromCanonical(options) {
             dryRun: !!options.dryRun,
         });
     }
+    if (target === "all" || target === "rule") {
+        syncManagedRuleInstructions({
+            paths: options.paths,
+            providers,
+            rules: managedInstructionRules,
+            generated: generatedRules,
+            updated: updatedRuleInstructionFiles,
+            retained: retainedRuleInstructionFiles,
+            previouslyTracked: new Set(effectiveManifest.generatedByEntity?.rule ?? []),
+            dryRun: !!options.dryRun,
+        });
+        if (providers.includes("cursor") && options.paths.scope === "local") {
+            syncCursorRules({
+                paths: options.paths,
+                rules,
+                generated: generatedRules,
+                dryRun: !!options.dryRun,
+            });
+        }
+        if (providers.includes("copilot") && options.paths.scope === "global") {
+            syncCopilotDiscoverySettings({
+                paths: options.paths,
+                dryRun: !!options.dryRun,
+                includeInstructionLocations: true,
+            });
+        }
+    }
     if (providers.includes("codex")) {
         const includeRoles = target === "all" || target === "agent";
         const includeMcp = target === "all" || target === "mcp";
@@ -113,18 +160,23 @@ export async function syncFromCanonical(options) {
     if (target === "all" || target === "mcp") {
         nextByEntity.mcp = [...generatedMcp].sort();
     }
+    if (target === "all" || target === "rule") {
+        nextByEntity.rule = [...generatedRules].sort();
+    }
     nextManifest.generatedByEntity = pruneGeneratedByEntity(nextByEntity);
     nextManifest.generatedFiles = [
         ...new Set([
             ...(nextManifest.generatedByEntity.agent ?? []),
             ...(nextManifest.generatedByEntity.command ?? []),
             ...(nextManifest.generatedByEntity.mcp ?? []),
+            ...(nextManifest.generatedByEntity.rule ?? []),
             ...(nextManifest.generatedByEntity.skill ?? []),
         ]),
     ].sort();
     const removedFiles = await removeStaleGeneratedFiles({
         oldManifest: manifest,
         newManifest: nextManifest,
+        protectedFiles: retainedRuleInstructionFiles,
         dryRun: !!options.dryRun,
         yes: !!options.yes,
         nonInteractive: !!options.nonInteractive,
@@ -139,7 +191,12 @@ export async function syncFromCanonical(options) {
     }
     return {
         providers,
-        generatedFiles: nextManifest.generatedFiles,
+        generatedFiles: [
+            ...new Set([
+                ...nextManifest.generatedFiles,
+                ...updatedRuleInstructionFiles,
+            ]),
+        ].sort(),
         removedFiles,
     };
 }
@@ -232,15 +289,36 @@ function syncProviderCommands(options) {
     for (const command of options.commands) {
         const fileName = mapProviderCommandFileName(options.provider, command.fileName);
         const outputPath = path.join(providerDir, fileName);
+        const content = renderCommandForProvider(command, options.provider);
+        if (content === null)
+            continue;
         if (!options.dryRun) {
             ensureDir(path.dirname(outputPath));
-            writeTextAtomic(outputPath, command.content);
+            writeTextAtomic(outputPath, content);
         }
         options.generated.add(outputPath);
     }
 }
 function mapProviderCommandFileName(provider, fileName) {
     const lower = fileName.toLowerCase();
+    if (provider === "gemini") {
+        if (lower.endsWith(".toml"))
+            return fileName;
+        if (lower.endsWith(".prompt.md")) {
+            return `${fileName.slice(0, -".prompt.md".length)}.toml`;
+        }
+        if (lower.endsWith(".md")) {
+            return `${fileName.slice(0, -3)}.toml`;
+        }
+        if (lower.endsWith(".mdc")) {
+            return `${fileName.slice(0, -4)}.toml`;
+        }
+        const ext = path.extname(fileName);
+        if (ext) {
+            return `${fileName.slice(0, -ext.length)}.toml`;
+        }
+        return `${fileName}.toml`;
+    }
     if (provider === "copilot") {
         if (lower.endsWith(".prompt.md"))
             return fileName;
@@ -261,6 +339,21 @@ function mapProviderCommandFileName(provider, fileName) {
     }
     return fileName;
 }
+function syncCursorRules(options) {
+    if (options.paths.scope !== "local") {
+        return;
+    }
+    const rulesDir = getCursorRulesDir(options.paths);
+    for (const rule of options.rules) {
+        const outputPath = path.join(rulesDir, `${rule.id}.mdc`);
+        const content = renderRuleForCursor(rule);
+        if (!options.dryRun) {
+            ensureDir(path.dirname(outputPath));
+            writeTextAtomic(outputPath, content);
+        }
+        options.generated.add(outputPath);
+    }
+}
 function syncProviderMcp(options) {
     for (const provider of options.providers) {
         if (provider === "codex")
@@ -276,8 +369,18 @@ function syncProviderMcp(options) {
             continue;
         }
         if (provider === "claude") {
-            const mcpPath = getClaudeMcpPath(options.paths);
             const settingsPath = getClaudeSettingsPath(options.paths);
+            const settings = readClaudeSettingsForSync(options.paths);
+            if (options.paths.scope === "global") {
+                maybeMigrateClaudeGlobalSettings({
+                    paths: options.paths,
+                    settingsPath,
+                    settings,
+                    dryRun: options.dryRun,
+                });
+                continue;
+            }
+            const mcpPath = getClaudeMcpPath(options.paths);
             const claudeServers = mapMcpServers(resolved, [
                 "type",
                 "url",
@@ -292,7 +395,6 @@ function syncProviderMcp(options) {
             }
             maybeWriteJson(mcpPath, { mcpServers: claudeServers }, options.dryRun);
             options.generated.add(mcpPath);
-            const settings = readJsonIfExists(settingsPath) ?? {};
             settings.enabledMcpjsonServers = Object.keys(claudeServers).sort();
             maybeWriteJson(settingsPath, settings, options.dryRun);
             options.generated.add(settingsPath);
@@ -396,6 +498,260 @@ function syncProviderMcp(options) {
         }
     }
 }
+function syncManagedRuleInstructions(options) {
+    const cleanupProviders = options.paths.scope === "global"
+        ? ["claude", "gemini", "copilot", "opencode"]
+        : ALL_PROVIDERS;
+    const activeTargets = new Set(getRuleInstructionPaths(options.paths, options.providers));
+    if (options.paths.scope === "global" && activeTargets.size === 0) {
+        return;
+    }
+    const cleanupTargets = new Set(getRuleInstructionPaths(options.paths, cleanupProviders));
+    for (const targetPath of cleanupTargets) {
+        if (!fs.existsSync(targetPath)) {
+            continue;
+        }
+        const stat = fs.lstatSync(targetPath);
+        if (!stat.isFile() || stat.isSymbolicLink()) {
+            options.retained.add(targetPath);
+            continue;
+        }
+        const existing = readTextIfExists(targetPath);
+        if (existing === null) {
+            continue;
+        }
+        const next = upsertManagedRuleBlocks(existing, activeTargets.has(targetPath) ? options.rules : []);
+        const shouldTrackGenerated = activeTargets.has(targetPath) &&
+            options.rules.length > 0 &&
+            next.trim().length > 0;
+        if (shouldTrackGenerated) {
+            options.generated.add(targetPath);
+        }
+        const shouldRetainOnDisk = !shouldTrackGenerated &&
+            next.trim().length > 0 &&
+            fs.existsSync(targetPath);
+        if (shouldRetainOnDisk) {
+            options.retained.add(targetPath);
+        }
+        if (next === existing)
+            continue;
+        options.updated.add(targetPath);
+        if (!options.dryRun) {
+            if (next.trim().length === 0) {
+                if (!options.previouslyTracked.has(targetPath)) {
+                    removeFileIfExists(targetPath);
+                }
+            }
+            else {
+                writeTextAtomic(targetPath, next);
+            }
+        }
+    }
+}
+function syncCopilotDiscoverySettings(options) {
+    const settingsPath = getVsCodeSettingsPath(options.paths.homeDir);
+    const settings = readVsCodeSettings(settingsPath);
+    if (!settings) {
+        return;
+    }
+    if (options.includePromptLocations) {
+        appendPathSetting(settings, "chat.promptFilesLocations", path.join(options.paths.homeDir, ".copilot", "prompts"));
+    }
+    if (options.includeAgentLocations) {
+        appendPathSetting(settings, "chat.agentFilesLocations", path.join(options.paths.homeDir, ".copilot", "agents"));
+    }
+    if (options.includeInstructionLocations) {
+        const instructionPath = path.join(options.paths.homeDir, ".copilot", "copilot-instructions.md");
+        setPathSettingEnabled(settings, "chat.instructionsFilesLocations", instructionPath, fs.existsSync(instructionPath));
+    }
+    maybeWriteJson(settingsPath, settings, options.dryRun);
+}
+function readVsCodeSettings(settingsPath) {
+    const raw = readTextIfExists(settingsPath);
+    if (raw === null) {
+        return {};
+    }
+    const parsed = parseJsonOrJsonc(raw);
+    if (!isObject(parsed)) {
+        return null;
+    }
+    return parsed;
+}
+function readClaudeSettingsForSync(paths) {
+    const settingsPath = getClaudeSettingsPath(paths);
+    const settings = readJsonIfExists(settingsPath);
+    if (isObject(settings)) {
+        return { ...settings };
+    }
+    if (paths.scope === "global") {
+        const legacySettingsPath = path.join(paths.homeDir, ".claude.json");
+        const legacySettings = readJsonIfExists(legacySettingsPath);
+        if (isObject(legacySettings)) {
+            return { ...legacySettings };
+        }
+    }
+    return {};
+}
+function maybeMigrateClaudeGlobalSettings(options) {
+    const nextSettings = { ...options.settings };
+    delete nextSettings.enabledMcpjsonServers;
+    const legacySettingsPath = path.join(options.paths.homeDir, ".claude.json");
+    const hasCurrentSettings = fs.existsSync(options.settingsPath) &&
+        fs.statSync(options.settingsPath).isFile();
+    const hasLegacySettings = fs.existsSync(legacySettingsPath) &&
+        fs.statSync(legacySettingsPath).isFile();
+    const shouldWrite = hasCurrentSettings ||
+        (hasLegacySettings && Object.keys(nextSettings).length > 0);
+    if (shouldWrite) {
+        maybeWriteJson(options.settingsPath, nextSettings, options.dryRun);
+    }
+}
+function parseJsonOrJsonc(input) {
+    if (input.trim() === "") {
+        return {};
+    }
+    try {
+        return JSON.parse(input);
+    }
+    catch {
+        try {
+            const withoutComments = stripJsonComments(input);
+            const normalized = stripTrailingJsonCommas(withoutComments);
+            if (normalized.trim() === "") {
+                return {};
+            }
+            return JSON.parse(normalized);
+        }
+        catch {
+            return null;
+        }
+    }
+}
+function stripJsonComments(input) {
+    let result = "";
+    let inString = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const char = input[i];
+        const next = i + 1 < input.length ? input[i + 1] : "";
+        if (inLineComment) {
+            if (char === "\n") {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                i += 1;
+            }
+            else if (char === "\n") {
+                result += char;
+            }
+            continue;
+        }
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            i += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            i += 1;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+function stripTrailingJsonCommas(input) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    for (let i = 0; i < input.length; i += 1) {
+        const char = input[i];
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+                continue;
+            }
+            if (char === "\\") {
+                escaped = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === '"') {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === ",") {
+            let lookahead = i + 1;
+            while (lookahead < input.length && /\s/.test(input[lookahead] ?? "")) {
+                lookahead += 1;
+            }
+            const next = input[lookahead];
+            if (next === "}" || next === "]") {
+                continue;
+            }
+        }
+        result += char;
+    }
+    return result;
+}
+function appendPathSetting(settings, key, settingPath) {
+    const existing = Array.isArray(settings[key])
+        ? settings[key].filter((value) => typeof value === "string" && value.trim() !== "")
+        : [];
+    if (!existing.includes(settingPath)) {
+        existing.push(settingPath);
+    }
+    settings[key] = existing;
+}
+function setPathSettingEnabled(settings, key, settingPath, enabled) {
+    if (enabled) {
+        appendPathSetting(settings, key, settingPath);
+        return;
+    }
+    const existing = Array.isArray(settings[key])
+        ? settings[key].filter((value) => typeof value === "string" &&
+            value.trim() !== "" &&
+            value !== settingPath)
+        : [];
+    if (existing.length === 0) {
+        delete settings[key];
+        return;
+    }
+    settings[key] = existing;
+}
 function syncCodex(options) {
     const codexDir = getCodexRootDir(options.paths);
     const codexConfigPath = getCodexConfigPath(options.paths);
@@ -437,10 +793,11 @@ function syncCodex(options) {
                 continue;
             const roleTomlPath = path.join(codexAgentsDir, `${role}.toml`);
             const roleInstructionsPath = path.join(codexAgentsDir, `${role}.instructions.md`);
-            const roleToml = buildCodexRoleToml(roleInstructionsPath, codexConfig);
+            const developerInstructions = resolveCodexDeveloperInstructions(agent.body, codexConfig);
+            const roleToml = buildCodexRoleToml(developerInstructions, codexConfig);
             if (!options.dryRun) {
                 ensureDir(codexAgentsDir);
-                writeTextAtomic(roleInstructionsPath, `${agent.body.trimStart()}\n`);
+                writeTextAtomic(roleInstructionsPath, `${developerInstructions}\n`);
                 writeTextAtomic(roleTomlPath, TOML.stringify(roleToml));
             }
             options.generated.add(roleTomlPath);
@@ -490,9 +847,16 @@ function resolveTrackedCodexEntries(trackedEntries, fallbackEntries) {
     const tracked = Array.isArray(trackedEntries) ? trackedEntries : [];
     return [...new Set([...tracked, ...fallbackEntries])].sort();
 }
-function buildCodexRoleToml(roleInstructionsPath, providerConfig) {
+function resolveCodexDeveloperInstructions(agentBody, providerConfig) {
+    if (typeof providerConfig.developerInstructions === "string" &&
+        providerConfig.developerInstructions.trim() !== "") {
+        return providerConfig.developerInstructions.trim();
+    }
+    return agentBody.trimStart().trimEnd();
+}
+function buildCodexRoleToml(developerInstructions, providerConfig) {
     const roleToml = {
-        model_instructions_file: `./${path.basename(roleInstructionsPath)}`,
+        developer_instructions: developerInstructions,
     };
     if (typeof providerConfig.model === "string") {
         roleToml.model = providerConfig.model;
@@ -500,6 +864,12 @@ function buildCodexRoleToml(roleInstructionsPath, providerConfig) {
     if (typeof providerConfig.reasoningEffort === "string") {
         roleToml.model_reasoning_effort = providerConfig.reasoningEffort;
     }
+    if (typeof providerConfig.reasoningSummary === "string") {
+        roleToml.model_reasoning_summary = providerConfig.reasoningSummary;
+    }
+    if (typeof providerConfig.verbosity === "string") {
+        roleToml.model_verbosity = providerConfig.verbosity;
+    }
     if (typeof providerConfig.approvalPolicy === "string") {
         roleToml.approval_policy = providerConfig.approvalPolicy;
     }
@@ -507,9 +877,7 @@ function buildCodexRoleToml(roleInstructionsPath, providerConfig) {
         roleToml.sandbox_mode = providerConfig.sandboxMode;
     }
     if (typeof providerConfig.webSearch === "boolean") {
-        roleToml.tools = {
-            web_search: providerConfig.webSearch,
-        };
+        roleToml.web_search = providerConfig.webSearch;
     }
     return roleToml;
 }
@@ -536,8 +904,10 @@ function maybeWriteJson(filePath, payload, dryRun) {
 async function removeStaleGeneratedFiles(options) {
     const oldSet = new Set(options.oldManifest.generatedFiles);
     const newSet = new Set(options.newManifest.generatedFiles);
+    const protectedSet = new Set(options.protectedFiles ?? []);
     const stale = [...oldSet]
         .filter((filePath) => !newSet.has(filePath))
+        .filter((filePath) => !protectedSet.has(filePath))
         .filter((filePath) => fs.existsSync(filePath));
     if (stale.length === 0)
         return [];
@@ -574,6 +944,7 @@ function normalizeGeneratedByEntity(manifest) {
         agent: Array.isArray(source.agent) ? [...source.agent] : [],
         command: Array.isArray(source.command) ? [...source.command] : [],
         mcp: Array.isArray(source.mcp) ? [...source.mcp] : [],
+        rule: Array.isArray(source.rule) ? [...source.rule] : [],
         skill: Array.isArray(source.skill) ? [...source.skill] : [],
     };
 }
@@ -582,6 +953,7 @@ function inferGeneratedByEntityFromLegacyFiles(generatedFiles) {
         agent: [],
         command: [],
         mcp: [],
+        rule: [],
         skill: [],
     };
     for (const filePath of generatedFiles) {
@@ -605,31 +977,45 @@ function classifyLegacyGeneratedFile(filePath) {
     if (isLegacyMcpOutputPath(normalized)) {
         return ["mcp"];
     }
+    if (isLegacyRuleOutputPath(normalized)) {
+        return ["agent", "rule"];
+    }
     // Preserve unknown generated paths during scoped syncs.
-    return ["agent", "command", "mcp"];
+    return ["agent", "command", "mcp", "rule"];
 }
 function isLegacyCommandOutputPath(normalizedPath) {
     return (normalizedPath.includes("/.cursor/commands/") ||
         normalizedPath.includes("/.claude/commands/") ||
         normalizedPath.includes("/.opencode/commands/") ||
         normalizedPath.includes("/.gemini/commands/") ||
+        normalizedPath.includes("/.copilot/prompts/") ||
         normalizedPath.includes("/.github/prompts/") ||
         normalizedPath.includes("/.codex/prompts/") ||
         normalizedPath.includes("/.pi/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("/.copilot/agents/") ||
         normalizedPath.includes("/.github/agents/") ||
         normalizedPath.includes("/.codex/agents/") ||
         normalizedPath.includes("/.pi/agents/"));
 }
+function isLegacyRuleOutputPath(normalizedPath) {
+    return (normalizedPath.includes("/.cursor/rules/") ||
+        normalizedPath.endsWith("/agents.md") ||
+        normalizedPath.endsWith("/claude.md") ||
+        normalizedPath.endsWith("/gemini.md") ||
+        normalizedPath.endsWith("/.github/copilot-instructions.md") ||
+        normalizedPath.endsWith("/.copilot/copilot-instructions.md") ||
+        normalizedPath.endsWith("/.config/opencode/agents.md"));
+}
 function isLegacyMcpOutputPath(normalizedPath) {
     return (normalizedPath.endsWith("/.cursor/mcp.json") ||
         normalizedPath.endsWith("/.mcp.json") ||
+        normalizedPath.endsWith("/.claude.json") ||
         normalizedPath.endsWith("/.claude/settings.json") ||
         normalizedPath.endsWith("/.opencode/opencode.json") ||
         normalizedPath.endsWith("/.gemini/settings.json") ||
@@ -643,7 +1029,7 @@ function isLegacyCodexConfigPath(normalizedPath) {
 }
 function pruneGeneratedByEntity(value) {
     const next = {};
-    for (const entity of ["agent", "command", "mcp", "skill"]) {
+    for (const entity of ["agent", "command", "mcp", "rule", "skill"]) {
         const files = value[entity];
         if (!files || files.length === 0)
             continue;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export declare const ALL_PROVIDERS: readonly ["cursor", "claude", "codex", "opencode", "gemini", "copilot", "pi"];
 export type Provider = (typeof ALL_PROVIDERS)[number];
 export type Scope = "local" | "global";
-export type EntityType = "agent" | "command" | "mcp" | "skill";
+export type EntityType = "agent" | "command" | "mcp" | "rule" | "skill";
 export type SelectionMode = "all" | "custom";
 export interface AgentFrontmatter {
     name: string;
@@ -37,6 +37,9 @@ export interface LockEntry {
     commandRenameMap?: Record<string, string>;
     importedMcpServers: string[];
     selectedSourceMcpServers?: string[];
+    importedRules: string[];
+    selectedSourceRules?: string[];
+    ruleRenameMap?: Record<string, string>;
     importedSkills: string[];
     selectedSourceSkills?: string[];
     skillsProviders?: Provider[];
@@ -64,6 +67,7 @@ export interface ScopePaths {
     agentsRoot: string;
     agentsDir: string;
     commandsDir: string;
+    rulesDir: string;
     skillsDir: string;
     mcpPath: string;
     lockPath: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentloom",
-  "version": "0.1.5",
+  "version": "0.1.7",
   "description": "Unified agent and MCP sync CLI for multi-provider AI tooling",
   "type": "module",
   "bin": {