agentloom 0.1.5 → 0.1.7

package/dist/core/importer.js

@@ -1,14 +1,19 @@
 import fs from "node:fs";
 import path from "node:path";
 import { cancel, isCancel, multiselect, select, text as promptText, } from "@clack/prompts";
+import TOML from "@iarna/toml";
+import matter from "gray-matter";
+import YAML from "yaml";
 import { buildAgentMarkdown, parseAgentsDir, targetFileNameForAgent, } from "./agents.js";
-import { normalizeCommandSelector, parseCommandsDir, resolveCommandSelections, } from "./commands.js";
-import { applySkillProviderSideEffects, copySkillArtifacts, normalizeSkillSelector, parseSkillsDir, resolveSkillSelections, skillContentMatchesTarget, } from "./skills.js";
-import { ensureDir, hashContent, readJsonIfExists, relativePosix, slugify, writeTextAtomic, } from "./fs.js";
+import { normalizeCommandArgumentsForCanonical, normalizeCommandSelector, parseCommandsDir, resolveCommandSelections, } from "./commands.js";
+import { normalizeRuleSelector, parseRulesDir, resolveRuleSelections, stripRuleFileExtension, } from "./rules.js";
+import { applySkillProviderSideEffects, copySkillArtifacts, normalizeSkillSelector, parseSkillsDir, resolveSkillSelector, resolveSkillSelections, skillContentMatchesTarget, } from "./skills.js";
+import { ensureDir, hashContent, isObject, readJsonIfExists, relativePosix, slugify, writeTextAtomic, } from "./fs.js";
 import { ALL_PROVIDERS } from "../types.js";
 import { readLockfile, upsertLockEntry, writeLockfile } from "./lockfile.js";
 import { readCanonicalMcp, writeCanonicalMcp } from "./mcp.js";
-import { discoverSourceAgentsDir, discoverSourceCommandsDir, discoverSourceMcpPath, discoverSourceSkillsDir, prepareSource, } from "./sources.js";
+import { discoverPluginSourceRoots, discoverSourceAgentsDirs, discoverSourceCommandsDirs, discoverSourceMcpPaths, discoverSourceRulesDirs, discoverSourceSkillsDirs, prepareSource, } from "./sources.js";
+import { isProviderEntityFileName } from "./provider-entity-validation.js";
 export class NonInteractiveConflictError extends Error {
     constructor(message) {
         super(message);
@@ -24,10 +29,13 @@ export async function importSource(options) {
     const requireAgents = options.requireAgents ?? shouldImportAgents;
     const shouldImportCommands = options.importCommands ?? true;
     const shouldImportMcp = options.importMcp ?? true;
+    const shouldImportRules = options.importRules ?? false;
+    const requireRules = options.requireRules ?? shouldImportRules;
     const shouldImportSkills = options.importSkills ?? false;
     if (!shouldImportAgents &&
         !shouldImportCommands &&
         !shouldImportMcp &&
+        !shouldImportRules &&
         !shouldImportSkills) {
         throw new Error("No import targets selected.");
     }
@@ -43,50 +51,77 @@ export async function importSource(options) {
             ? `${options.source} (subdir: ${options.subdir})`
             : options.source;
     try {
-        const sourceAgentsDir = shouldImportAgents
-            ? discoverSourceAgentsDir(prepared.importRoot)
-            : null;
-        const sourceCommandsDir = shouldImportCommands
-            ? discoverSourceCommandsDir(prepared.importRoot)
-            : null;
-        const sourceMcpPath = shouldImportMcp
-            ? discoverSourceMcpPath(prepared.importRoot)
-            : null;
-        const sourceSkillsDir = shouldImportSkills
-            ? discoverSourceSkillsDir(prepared.importRoot)
-            : null;
-        const sourceAgents = sourceAgentsDir ? parseAgentsDir(sourceAgentsDir) : [];
-        const sourceCommands = sourceCommandsDir
-            ? parseCommandsDir(sourceCommandsDir)
+        const pluginSourceRoots = discoverPluginSourceRoots(prepared.importRoot);
+        const sourceAgentsDirs = shouldImportAgents
+            ? discoverSourceAgentsDirs(prepared.importRoot)
+            : [];
+        const sourceCommandsDirs = shouldImportCommands
+            ? discoverSourceCommandsDirs(prepared.importRoot)
+            : [];
+        const sourceMcpPaths = shouldImportMcp
+            ? discoverSourceMcpPaths(prepared.importRoot)
             : [];
-        const sourceMcp = sourceMcpPath
-            ? normalizeMcp(readJsonIfExists(sourceMcpPath))
+        const sourceRulesDirs = shouldImportRules
+            ? discoverSourceRulesDirs(prepared.importRoot)
+            : [];
+        const sourceSkillsDirs = shouldImportSkills
+            ? discoverSourceSkillsDirs(prepared.importRoot)
+            : [];
+        const sourceAgents = sourceAgentsDirs.length > 0
+            ? parseSourceAgentsForImport(sourceAgentsDirs, pluginSourceRoots)
+            : [];
+        const sourceCommands = sourceCommandsDirs.length > 0
+            ? parseSourceCommandsForImport(sourceCommandsDirs, pluginSourceRoots)
+            : [];
+        const sourceMcp = sourceMcpPaths.length > 0
+            ? parseSourceMcpForImport(sourceMcpPaths, pluginSourceRoots)
             : null;
-        const sourceSkills = sourceSkillsDir ? parseSkillsDir(sourceSkillsDir) : [];
+        const sourceRules = sourceRulesDirs.length > 0
+            ? parseSourceRulesForImport(sourceRulesDirs, pluginSourceRoots)
+            : [];
+        const sourceSkills = sourceSkillsDirs.length > 0
+            ? parseSourceSkillsForImport(sourceSkillsDirs, pluginSourceRoots)
+            : [];
+        const sourceAgentsDir = sourceAgentsDirs[0] ?? null;
+        const sourceCommandsDir = sourceCommandsDirs[0] ?? null;
+        const sourceMcpPath = sourceMcpPaths[0] ?? null;
+        const sourceRulesDir = sourceRulesDirs[0] ?? null;
+        const sourceSkillsDir = sourceSkillsDirs[0] ?? null;
         const hasExplicitCommandSelection = (options.commandSelectors?.length ?? 0) > 0;
         const isAggregateImport = shouldImportAgents &&
             shouldImportCommands &&
             shouldImportMcp &&
+            (options.importRules === undefined || shouldImportRules) &&
             shouldImportSkills;
-        if (shouldImportAgents && requireAgents && !sourceAgentsDir) {
-            throw new Error(`No source agents directory found under ${prepared.importRoot} (expected agents/ or .agents/agents/).`);
+        if (shouldImportAgents && requireAgents && sourceAgentsDirs.length === 0) {
+            throw new Error(`No source agents directory found under ${prepared.importRoot} (expected agents/, .agents/agents/, or .github/agents/, including plugin sources declared in .claude-plugin/marketplace.json).`);
         }
         if (shouldImportAgents && requireAgents && sourceAgents.length === 0) {
             throw new Error(`No agent files found in ${sourceAgentsDir}.`);
         }
-        if (shouldImportCommands && options.requireCommands && !sourceCommandsDir) {
-            throw new Error(`No source commands directory found under ${prepared.importRoot} (expected .agents/commands/, commands/, or prompts/).`);
+        if (shouldImportCommands &&
+            options.requireCommands &&
+            sourceCommandsDirs.length === 0) {
+            throw new Error(`No source commands directory found under ${prepared.importRoot} (expected .agents/commands/, commands/, prompts/, .gemini/commands/, or .github/prompts/, including plugin sources declared in .claude-plugin/marketplace.json).`);
         }
         if (shouldImportCommands &&
             options.requireCommands &&
             sourceCommands.length === 0) {
             throw new Error(`No command files found in ${sourceCommandsDir}.`);
         }
-        if (shouldImportMcp && options.requireMcp && !sourceMcpPath) {
-            throw new Error(`No source mcp.json found under ${prepared.importRoot} (expected mcp.json or .agents/mcp.json).`);
+        if (shouldImportMcp && options.requireMcp && sourceMcpPaths.length === 0) {
+            throw new Error(`No source mcp.json found under ${prepared.importRoot} (expected mcp.json or .agents/mcp.json, including plugin sources declared in .claude-plugin/marketplace.json).`);
+        }
+        if (shouldImportRules && requireRules && sourceRulesDirs.length === 0) {
+            throw new Error(`No source rules directory found under ${prepared.importRoot} (expected .agents/rules/ or rules/, including plugin sources declared in .claude-plugin/marketplace.json).`);
+        }
+        if (shouldImportRules && requireRules && sourceRules.length === 0) {
+            throw new Error(`No rule files found in ${sourceRulesDir}.`);
         }
-        if (shouldImportSkills && options.requireSkills && !sourceSkillsDir) {
-            throw new Error(`No source skills directory found under ${prepared.importRoot} (expected .agents/skills/, skills/, or root SKILL.md).`);
+        if (shouldImportSkills &&
+            options.requireSkills &&
+            sourceSkillsDirs.length === 0) {
+            throw new Error(`No source skills directory found under ${prepared.importRoot} (expected .agents/skills/, skills/, or root SKILL.md, including plugin sources declared in .claude-plugin/marketplace.json).`);
         }
         if (shouldImportSkills &&
             options.requireSkills &&
@@ -96,9 +131,10 @@ export async function importSource(options) {
         if (isAggregateImport &&
             sourceAgents.length === 0 &&
             sourceCommands.length === 0 &&
+            sourceRules.length === 0 &&
             sourceSkills.length === 0 &&
             Object.keys(sourceMcp?.mcpServers ?? {}).length === 0) {
-            throw new Error(`No importable entities found in source "${sourceLocation}".\nExpected agents/, .agents/agents/, commands/, .agents/commands/, prompts/, mcp.json/.agents/mcp.json, skills/, .agents/skills/, or root SKILL.md.`);
+            throw new Error(`No importable entities found in source "${sourceLocation}".\nExpected agents/, .agents/agents/, .github/agents/, commands/, .agents/commands/, prompts/, .gemini/commands/, .github/prompts/, mcp.json/.agents/mcp.json, rules/.agents/rules/, skills/, .agents/skills/, root SKILL.md, or plugin sources from .claude-plugin/marketplace.json.`);
         }
         const shouldResolveAgents = shouldImportAgents &&
             (sourceAgents.length > 0 ||
@@ -145,6 +181,21 @@ export async function importSource(options) {
             selectedSourceMcpServers = mcpSelection.selectedServerNames;
             mcpSelectionMode = mcpSelection.selectionMode;
         }
+        let selectedRules = [];
+        let selectedSourceRules = [];
+        let ruleSelectionMode = "all";
+        if (shouldImportRules && sourceRulesDir) {
+            const ruleSelection = await resolveRulesToImport({
+                sourceRules,
+                selectors: options.ruleSelectors ?? [],
+                promptForRules: options.promptForRules ?? true,
+                nonInteractive: Boolean(options.nonInteractive),
+                selectionMode: options.selectionMode,
+            });
+            selectedRules = ruleSelection.selectedRules;
+            ruleSelectionMode = ruleSelection.selectionMode;
+            selectedSourceRules = selectedRules.map((rule) => rule.fileName);
+        }
         let selectedSkills = [];
         let selectedSourceSkills = [];
         let skillSelectionMode = "all";
@@ -157,8 +208,8 @@ export async function importSource(options) {
                 selectionMode: options.selectionMode,
             });
             selectedSkills = skillSelection.selectedSkills;
+            selectedSourceSkills = skillSelection.selectedSourceSkills;
             skillSelectionMode = skillSelection.selectionMode;
-            selectedSourceSkills = selectedSkills.map((skill) => skill.name);
         }
         const importedAgents = [];
         if (shouldImportAgents && selection.selectedAgents.length > 0) {
@@ -240,6 +291,47 @@ export async function importSource(options) {
             }
             importedMcpServers.push(...selectedSourceMcpServers);
         }
+        const importedRules = [];
+        const telemetryRules = [];
+        const importedRuleRenameMap = {};
+        if (shouldImportRules && sourceRulesDir) {
+            if (selectedRules.length > 0) {
+                ensureDir(options.paths.rulesDir);
+            }
+            for (const [index, rule] of selectedRules.entries()) {
+                let targetFileName = rule.fileName;
+                const mappedTargetFileName = resolveMappedTargetRuleFileName(rule.fileName, options.ruleRenameMap);
+                if (mappedTargetFileName) {
+                    targetFileName = mappedTargetFileName;
+                }
+                else if (options.rename &&
+                    selectedRules.length === 1 &&
+                    importedAgents.length === 0 &&
+                    importedCommands.length === 0 &&
+                    importedMcpServers.length === 0 &&
+                    selectedSkills.length === 0) {
+                    targetFileName = `${slugify(options.rename) || "rule"}.md`;
+                }
+                const resolvedFileName = await resolveRuleConflict({
+                    targetFileName,
+                    ruleContent: rule.content,
+                    paths: options.paths,
+                    yes: !!options.yes,
+                    nonInteractive: !!options.nonInteractive,
+                    promptLabel: `${rule.fileName} (${index + 1}/${selectedRules.length})`,
+                });
+                if (!resolvedFileName)
+                    continue;
+                const targetPath = path.join(options.paths.rulesDir, resolvedFileName);
+                writeTextAtomic(targetPath, rule.content);
+                importedRules.push(relativePosix(options.paths.agentsRoot, targetPath));
+                telemetryRules.push({
+                    name: stripRuleFileExtension(rule.fileName),
+                    filePath: relativePosix(prepared.rootPath, rule.sourcePath),
+                });
+                importedRuleRenameMap[rule.fileName] = resolvedFileName;
+            }
+        }
         const importedSkills = [];
         const telemetrySkills = [];
         const importedSkillRenameMap = {};
@@ -249,21 +341,32 @@ export async function importSource(options) {
                 ensureDir(options.paths.skillsDir);
             }
             for (const [index, sourceSkill] of selectedSkills.entries()) {
-                let targetSkillDirName = slugify(sourceSkill.name) || "skill";
-                const mappedTargetSkillDirName = resolveMappedTargetSkillName(sourceSkill.name, options.skillRenameMap);
+                const canonicalSkillDirName = slugify(sourceSkill.name) || "skill";
+                const legacySkillDirName = slugify(sourceSkill.sourceDirName) || "skill";
+                let targetSkillDirName = canonicalSkillDirName;
+                const mappedTargetSkillDirName = resolveMappedTargetSkillName(sourceSkill, selectedSkills, options.skillRenameMap);
                 if (mappedTargetSkillDirName) {
-                    targetSkillDirName = mappedTargetSkillDirName;
+                    targetSkillDirName =
+                        mappedTargetSkillDirName === legacySkillDirName &&
+                            legacySkillDirName !== canonicalSkillDirName
+                            ? canonicalSkillDirName
+                            : mappedTargetSkillDirName;
                 }
                 else if (options.rename &&
                     selectedSkills.length === 1 &&
                     importedAgents.length === 0 &&
                     importedCommands.length === 0 &&
-                    importedMcpServers.length === 0) {
+                    importedMcpServers.length === 0 &&
+                    importedRules.length === 0) {
                     targetSkillDirName = slugify(options.rename) || "skill";
                 }
                 const resolvedSkillDirName = await resolveSkillConflict({
                     sourceSkill,
                     targetSkillDirName,
+                    legacySkillDirName: targetSkillDirName === canonicalSkillDirName
+                        ? legacySkillDirName
+                        : undefined,
+                    canonicalSkillDirName,
                     paths: options.paths,
                     yes: !!options.yes,
                     nonInteractive: !!options.nonInteractive,
@@ -272,10 +375,25 @@ export async function importSource(options) {
                 if (!resolvedSkillDirName)
                     continue;
                 const targetSkillDir = path.join(options.paths.skillsDir, resolvedSkillDirName);
+                if (resolvedSkillDirName === canonicalSkillDirName) {
+                    moveLegacySkillDirectoryToCanonicalIfUnchanged({
+                        sourceSkill,
+                        legacySkillDirName,
+                        canonicalSkillDirName,
+                        paths: options.paths,
+                    });
+                }
                 if (!skillContentMatchesTarget(sourceSkill, targetSkillDir)) {
                     fs.rmSync(targetSkillDir, { recursive: true, force: true });
                     copySkillArtifacts(sourceSkill, targetSkillDir);
                 }
+                if (resolvedSkillDirName === canonicalSkillDirName) {
+                    removeLegacySkillDirectory({
+                        legacySkillDirName,
+                        canonicalSkillDirName,
+                        paths: options.paths,
+                    });
+                }
                 importedSkills.push(resolvedSkillDirName);
                 telemetrySkills.push({
                     name: sourceSkill.name,
@@ -303,10 +421,12 @@ export async function importSource(options) {
             selectedSourceCommandFiles.length < sourceCommands.length;
         const selectedSubsetOfSourceMcp = sourceMcpServerNames.length > 0 &&
             selectedSourceMcpServers.length < sourceMcpServerNames.length;
+        const selectedSubsetOfSourceRules = sourceRules.length > 0 && selectedSourceRules.length < sourceRules.length;
         const selectedSubsetOfSourceSkills = sourceSkills.length > 0 &&
             selectedSourceSkills.length < sourceSkills.length;
         const shouldPersistCommandSelection = shouldImportCommands && commandSelectionMode === "custom";
         const shouldPersistMcpSelection = shouldImportMcp && mcpSelectionMode === "custom";
+        const shouldPersistRuleSelection = shouldImportRules && ruleSelectionMode === "custom";
         const shouldPersistSkillSelection = shouldImportSkills && skillSelectionMode === "custom";
         const selectedSourceCommandsForLock = shouldPersistCommandSelection || selectedSubsetOfSourceCommands
             ? selectedSourceCommandFiles
@@ -314,6 +434,9 @@ export async function importSource(options) {
         const selectedSourceMcpServersForLock = shouldPersistMcpSelection || selectedSubsetOfSourceMcp
             ? selectedSourceMcpServers
             : undefined;
+        const selectedSourceRulesForLock = shouldPersistRuleSelection || selectedSubsetOfSourceRules
+            ? selectedSourceRules
+            : undefined;
         const selectedSourceSkillsForLock = shouldPersistSkillSelection || selectedSubsetOfSourceSkills
             ? selectedSourceSkills
             : undefined;
@@ -321,6 +444,7 @@ export async function importSource(options) {
         const isCommandOnlyImport = !shouldImportAgents &&
             shouldImportCommands &&
             !shouldImportMcp &&
+            !shouldImportRules &&
             !shouldImportSkills;
         const existingEntry = isCommandOnlyImport
             ? findRelaxedCommandEntry(lockfile.entries, {
@@ -338,7 +462,9 @@ export async function importSource(options) {
                     : options.agents,
                 selectedSourceCommands: selectedSourceCommandsForLock,
                 selectedSourceMcpServers: selectedSourceMcpServersForLock,
+                selectedSourceRules: selectedSourceRulesForLock,
                 selectedSourceSkills: selectedSourceSkillsForLock,
+                selectedSkills,
                 skillsProviders: skillsProvidersForLock,
             });
         const shouldMergeCommandOnlyEntry = isCommandOnlyImport &&
@@ -360,6 +486,9 @@ export async function importSource(options) {
         const lockImportedMcpServers = shouldImportMcp
             ? importedMcpServers
             : (existingEntry?.importedMcpServers ?? []);
+        const lockImportedRules = shouldImportRules
+            ? importedRules
+            : (existingEntry?.importedRules ?? []);
         const lockImportedSkills = shouldImportSkills
             ? importedSkills
             : (existingEntry?.importedSkills ?? []);
@@ -392,11 +521,19 @@ export async function importSource(options) {
                 ? [...selectedSourceMcpServers]
                 : undefined
             : existingEntry?.selectedSourceMcpServers;
+        const lockSelectedSourceRules = shouldImportRules
+            ? shouldPersistRuleSelection || selectedSubsetOfSourceRules
+                ? [...selectedSourceRules]
+                : undefined
+            : existingEntry?.selectedSourceRules;
         const lockSelectedSourceSkills = shouldImportSkills
             ? shouldPersistSkillSelection || selectedSubsetOfSourceSkills
                 ? [...selectedSourceSkills]
                 : undefined
             : existingEntry?.selectedSourceSkills;
+        const lockRuleRenameMap = shouldImportRules
+            ? normalizeRuleRenameMap(importedRuleRenameMap)
+            : existingEntry?.ruleRenameMap;
         const lockSkillsProviders = shouldImportSkills
             ? (skillsProvidersForLock ?? existingEntry?.skillsProviders)
             : existingEntry?.skillsProviders;
@@ -426,6 +563,9 @@ export async function importSource(options) {
             commandRenameMap: lockCommandRenameMap,
             importedMcpServers: lockImportedMcpServers,
             selectedSourceMcpServers: lockSelectedSourceMcpServers,
+            importedRules: lockImportedRules,
+            selectedSourceRules: lockSelectedSourceRules,
+            ruleRenameMap: lockRuleRenameMap,
             importedSkills: lockImportedSkills,
             selectedSourceSkills: lockSelectedSourceSkills,
             skillsProviders: lockSkillsProviders,
@@ -438,6 +578,9 @@ export async function importSource(options) {
             commandRenameMap: lockCommandRenameMap ?? {},
             mcp: lockImportedMcpServers,
             selectedSourceMcpServers: lockSelectedSourceMcpServers ?? [],
+            rules: lockImportedRules,
+            selectedSourceRules: lockSelectedSourceRules ?? [],
+            ruleRenameMap: lockRuleRenameMap ?? {},
             skills: lockImportedSkills,
             selectedSourceSkills: lockSelectedSourceSkills ?? [],
             skillsProviders: lockSkillsProviders ?? [],
@@ -458,6 +601,9 @@ export async function importSource(options) {
             commandRenameMap: lockCommandRenameMap,
             importedMcpServers: lockImportedMcpServers,
             selectedSourceMcpServers: lockSelectedSourceMcpServers,
+            importedRules: lockImportedRules,
+            selectedSourceRules: lockSelectedSourceRules,
+            ruleRenameMap: lockRuleRenameMap,
             importedSkills: lockImportedSkills,
             selectedSourceSkills: lockSelectedSourceSkills,
             skillsProviders: lockSkillsProviders,
@@ -484,7 +630,9 @@ export async function importSource(options) {
             importedAgents,
             importedCommands,
             importedMcpServers,
+            importedRules,
             importedSkills,
+            telemetryRules: telemetryRules.length > 0 ? telemetryRules : undefined,
             telemetrySkills: telemetrySkills.length > 0 ? telemetrySkills : undefined,
             resolvedCommit: prepared.resolvedCommit,
         };
@@ -493,6 +641,504 @@ export async function importSource(options) {
         prepared.cleanup();
     }
 }
+function parseSourceAgentsForImport(sourceAgentsDirs, pluginSourceRoots) {
+    const sourceAgents = sourceAgentsDirs.flatMap((sourceAgentsDir) => {
+        if (isGitHubAgentsDir(sourceAgentsDir)) {
+            return parseGitHubAgentsDirForImport(sourceAgentsDir);
+        }
+        return parseAgentsDir(sourceAgentsDir);
+    });
+    assertNoPluginSourceCollisions({
+        entityLabel: "agent",
+        pluginSourceRoots,
+        entries: sourceAgents.map((agent) => ({
+            key: targetFileNameForAgent(agent),
+            sourcePath: agent.sourcePath,
+        })),
+    });
+    return sourceAgents;
+}
+function parseSourceCommandsForImport(sourceCommandsDirs, pluginSourceRoots) {
+    const sourceCommands = sourceCommandsDirs.flatMap((dirPath) => parseSourceCommandsFromDir(dirPath));
+    assertNoPluginSourceCollisions({
+        entityLabel: "command",
+        pluginSourceRoots,
+        entries: sourceCommands.map((command) => ({
+            key: toCanonicalCommandFileName(command.fileName),
+            sourcePath: command.sourcePath,
+        })),
+    });
+    return mergeCanonicalCommandFiles(sourceCommands);
+}
+function parseSourceMcpForImport(sourceMcpPaths, pluginSourceRoots) {
+    const mergedMcpServers = {};
+    const seenServerSource = new Map();
+    for (const sourceMcpPath of sourceMcpPaths) {
+        const sourceMcp = normalizeMcp(readJsonIfExists(sourceMcpPath));
+        for (const [serverName, serverConfig] of Object.entries(sourceMcp.mcpServers)) {
+            const pluginSourceRoot = resolvePluginSourceRootForPath(sourceMcpPath, pluginSourceRoots);
+            const existing = seenServerSource.get(serverName);
+            if (existing &&
+                existing.pluginSourceRoot &&
+                pluginSourceRoot &&
+                existing.pluginSourceRoot !== pluginSourceRoot) {
+                throw buildPluginCollisionError({
+                    entityLabel: "mcp server",
+                    key: serverName,
+                    sourcePaths: [existing.sourcePath, sourceMcpPath],
+                });
+            }
+            mergedMcpServers[serverName] = serverConfig;
+            seenServerSource.set(serverName, {
+                sourcePath: sourceMcpPath,
+                pluginSourceRoot,
+            });
+        }
+    }
+    return {
+        version: 1,
+        mcpServers: mergedMcpServers,
+    };
+}
+function parseSourceRulesForImport(sourceRulesDirs, pluginSourceRoots) {
+    const sourceRules = sourceRulesDirs.flatMap((sourceRulesDir) => parseRulesDir(sourceRulesDir));
+    assertNoPluginSourceCollisions({
+        entityLabel: "rule",
+        pluginSourceRoots,
+        entries: sourceRules.map((rule) => ({
+            key: rule.id,
+            sourcePath: rule.sourcePath,
+        })),
+    });
+    return sourceRules;
+}
+function parseSourceSkillsForImport(sourceSkillsDirs, pluginSourceRoots) {
+    const sourceSkills = sourceSkillsDirs.flatMap((sourceSkillsDir) => parseSkillsDir(sourceSkillsDir));
+    assertNoPluginSourceCollisions({
+        entityLabel: "skill",
+        pluginSourceRoots,
+        entries: sourceSkills.map((skill) => ({
+            key: normalizeSkillSelector(skill.name),
+            sourcePath: skill.skillPath,
+        })),
+    });
+    assertNoDuplicateSkillNames(sourceSkills);
+    return sourceSkills;
+}
+function assertNoDuplicateSkillNames(sourceSkills) {
+    const byName = new Map();
+    for (const skill of sourceSkills) {
+        const normalizedName = normalizeSkillSelector(skill.name);
+        if (!normalizedName)
+            continue;
+        const matches = byName.get(normalizedName) ?? [];
+        matches.push({
+            name: skill.name,
+            sourcePath: skill.skillPath,
+        });
+        byName.set(normalizedName, matches);
+    }
+    for (const matches of byName.values()) {
+        const sourcePaths = [...new Set(matches.map((item) => item.sourcePath))];
+        if (sourcePaths.length < 2) {
+            continue;
+        }
+        const locations = sourcePaths
+            .map((sourcePath) => `- ${sourcePath}`)
+            .join("\n");
+        throw new Error(`Conflicting skill "${matches[0]?.name ?? "unknown"}" found in source:\n${locations}\nEnsure each SKILL.md frontmatter name is unique.`);
+    }
+}
+function assertNoPluginSourceCollisions(options) {
+    if (options.pluginSourceRoots.length === 0 || options.entries.length === 0) {
+        return;
+    }
+    const byKey = new Map();
+    for (const entry of options.entries) {
+        const normalizedKey = entry.key.trim().toLowerCase();
+        if (!normalizedKey)
+            continue;
+        const pluginSourceRoot = resolvePluginSourceRootForPath(entry.sourcePath, options.pluginSourceRoots);
+        const group = byKey.get(normalizedKey) ?? [];
+        group.push({
+            key: entry.key,
+            sourcePath: entry.sourcePath,
+            pluginSourceRoot,
+        });
+        byKey.set(normalizedKey, group);
+    }
+    for (const matches of byKey.values()) {
+        const pluginRoots = [
+            ...new Set(matches
+                .map((item) => item.pluginSourceRoot)
+                .filter((item) => Boolean(item))),
+        ];
+        if (pluginRoots.length < 2) {
+            continue;
+        }
+        throw buildPluginCollisionError({
+            entityLabel: options.entityLabel,
+            key: matches[0]?.key ?? "unknown",
+            sourcePaths: matches.map((item) => item.sourcePath),
+        });
+    }
+}
+function buildPluginCollisionError(options) {
+    const locations = [...new Set(options.sourcePaths)]
+        .map((sourcePath) => `- ${sourcePath}`)
+        .join("\n");
+    return new Error(`Conflicting ${options.entityLabel} "${options.key}" found across plugin sources declared in .claude-plugin/marketplace.json:\n${locations}\nUse --subdir to import a single plugin source.`);
+}
+function resolvePluginSourceRootForPath(sourcePath, pluginSourceRoots) {
+    for (const pluginSourceRoot of [...pluginSourceRoots].sort((left, right) => right.length - left.length)) {
+        const normalizedRoot = path.resolve(pluginSourceRoot);
+        const normalizedPath = path.resolve(sourcePath);
+        if (normalizedPath === normalizedRoot ||
+            normalizedPath.startsWith(`${normalizedRoot}${path.sep}`)) {
+            return normalizedRoot;
+        }
+    }
+    return null;
+}
+function parseSourceCommandsFromDir(sourceCommandsDir) {
+    if (isGeminiCommandsDir(sourceCommandsDir)) {
+        const geminiMarkdownCommands = parseCommandsDir(sourceCommandsDir).filter((command) => isProviderEntityFileName({
+            provider: "gemini",
+            entity: "command",
+            fileName: command.fileName,
+        }));
+        const parsedCommands = mergeCommandsByCanonicalFileName([
+            ...parseGeminiTomlCommandsForImport(sourceCommandsDir),
+            ...geminiMarkdownCommands,
+        ]);
+        return parsedCommands.map((command) => normalizeGeminiCommandForImport(command));
+    }
+    const commands = parseCommandsDir(sourceCommandsDir);
+    if (!isGitHubPromptsDir(sourceCommandsDir)) {
+        return commands;
+    }
+    return commands
+        .filter((command) => isProviderEntityFileName({
+        provider: "copilot",
+        entity: "command",
+        fileName: command.fileName,
+    }))
+        .map((command) => normalizeGitHubPromptForImport(command));
+}
+function mergeCommandsByCanonicalFileName(commands) {
+    const byFileName = new Map();
+    for (const command of commands) {
+        if (!byFileName.has(command.fileName)) {
+            byFileName.set(command.fileName, command);
+        }
+    }
+    return [...byFileName.values()];
+}
+function isGitHubAgentsDir(sourceAgentsDir) {
+    return (path.basename(sourceAgentsDir).toLowerCase() === "agents" &&
+        path.basename(path.dirname(sourceAgentsDir)).toLowerCase() === ".github");
+}
+function isGitHubPromptsDir(sourceCommandsDir) {
+    return (path.basename(sourceCommandsDir).toLowerCase() === "prompts" &&
+        path.basename(path.dirname(sourceCommandsDir)).toLowerCase() === ".github");
+}
+function isGeminiCommandsDir(sourceCommandsDir) {
+    return (path.basename(sourceCommandsDir).toLowerCase() === "commands" &&
+        path.basename(path.dirname(sourceCommandsDir)).toLowerCase() === ".gemini");
+}
+function parseGeminiTomlCommandsForImport(sourceCommandsDir) {
+    return fs
+        .readdirSync(sourceCommandsDir, { withFileTypes: true })
+        .filter((entry) => entry.isFile())
+        .map((entry) => entry.name)
+        .filter((fileName) => isProviderEntityFileName({
+        provider: "gemini",
+        entity: "command",
+        fileName,
+    }))
+        .filter((fileName) => fileName.toLowerCase().endsWith(".toml"))
+        .sort((a, b) => a.localeCompare(b))
+        .map((fileName) => parseGeminiTomlCommandForImport(path.join(sourceCommandsDir, fileName)))
+        .filter((command) => command !== null);
+}
+function mergeCanonicalCommandFiles(commands) {
+    const merged = new Map();
+    for (const command of commands) {
+        const fileName = toCanonicalCommandFileName(command.fileName);
+        const normalizedCommand = fileName === command.fileName ? command : { ...command, fileName };
+        const existing = merged.get(fileName);
+        if (!existing) {
+            merged.set(fileName, normalizedCommand);
+            continue;
+        }
+        const existingHasBody = normalizeImportedCommandBody(existing.body).length > 0;
+        const incomingHasBody = normalizeImportedCommandBody(normalizedCommand.body).length > 0;
+        if (existingHasBody &&
+            incomingHasBody &&
+            !sameNormalizedImportedCommandBody(existing.body, normalizedCommand.body)) {
+            throw new Error(`Conflicting command bodies found for "${fileName}" in ${existing.sourcePath} and ${normalizedCommand.sourcePath}. Align the provider-specific prompts before importing, or import a single provider directory with --subdir.`);
+        }
+        const body = existingHasBody ? existing.body : normalizedCommand.body;
+        const frontmatter = mergeCommandFrontmatterForImport(existing.frontmatter, normalizedCommand.frontmatter);
+        merged.set(fileName, {
+            ...existing,
+            fileName,
+            body,
+            frontmatter,
+            content: buildCommandMarkdownForImport(frontmatter, body),
+        });
+    }
+    return [...merged.values()];
+}
+function sameNormalizedImportedCommandBody(left, right) {
+    return (normalizeImportedCommandBody(left) === normalizeImportedCommandBody(right));
+}
+function normalizeImportedCommandBody(value) {
+    return value.trim().replace(/\r\n/g, "\n");
+}
+function mergeCommandFrontmatterForImport(existing, incoming) {
+    if (!existing && !incoming) {
+        return undefined;
+    }
+    const merged = existing ? cloneUnknown(existing) : {};
+    for (const [key, value] of Object.entries(incoming ?? {})) {
+        const current = merged[key];
+        if (current === undefined) {
+            merged[key] = cloneUnknown(value);
+            continue;
+        }
+        if (isObject(current) && isObject(value)) {
+            merged[key] = {
+                ...cloneUnknown(value),
+                ...cloneUnknown(current),
+            };
+        }
+    }
+    return Object.keys(merged).length > 0 ? merged : undefined;
+}
+function parseGeminiTomlCommandForImport(sourcePath) {
+    const raw = fs.readFileSync(sourcePath, "utf8");
+    let parsed;
+    try {
+        parsed = TOML.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!isObject(parsed) || typeof parsed.prompt !== "string") {
+        return null;
+    }
+    const body = normalizeCommandArgumentsForCanonical(parsed.prompt, "gemini");
+    const frontmatter = cloneUnknown(parsed);
+    delete frontmatter.prompt;
+    const normalizedFrontmatter = Object.keys(frontmatter).length > 0 ? frontmatter : undefined;
+    const fileName = toCanonicalCommandFileName(path.basename(sourcePath));
+    const content = buildCommandMarkdownForImport(normalizedFrontmatter, body);
+    return {
+        fileName,
+        sourcePath,
+        content,
+        body,
+        frontmatter: normalizedFrontmatter,
+    };
+}
+function parseGitHubAgentsDirForImport(sourceAgentsDir) {
+    return fs
+        .readdirSync(sourceAgentsDir)
+        .filter((entry) => isProviderEntityFileName({
+        provider: "copilot",
+        entity: "agent",
+        fileName: entry,
+    }))
+        .sort((a, b) => a.localeCompare(b))
+        .map((entry) => parseGitHubAgentForImport(path.join(sourceAgentsDir, entry)));
+}
+function parseGitHubAgentForImport(sourcePath) {
+    const raw = fs.readFileSync(sourcePath, "utf8");
+    const parsed = matter(raw);
+    const data = isObject(parsed.data)
+        ? parsed.data
+        : {};
+    const fileName = path.basename(sourcePath);
+    const fallbackName = inferAgentNameFromFile(fileName);
+    const name = typeof data.name === "string" && data.name.trim().length > 0
+        ? data.name.trim()
+        : fallbackName;
+    const description = typeof data.description === "string" && data.description.trim().length > 0
+        ? data.description.trim()
+        : `Imported from Copilot agent "${name}".`;
+    const frontmatter = {
+        name,
+        description,
+    };
+    for (const provider of ALL_PROVIDERS) {
+        if (provider === "copilot")
+            continue;
+        const value = data[provider];
+        if (value === false || isObject(value)) {
+            frontmatter[provider] = cloneUnknown(value);
+        }
+    }
+    const inferredCopilotConfig = {};
+    for (const [key, value] of Object.entries(data)) {
+        if (key === "name" || key === "description")
+            continue;
+        if (ALL_PROVIDERS.includes(key))
+            continue;
+        inferredCopilotConfig[key] = cloneUnknown(value);
+    }
+    const explicitCopilot = data.copilot;
+    if (explicitCopilot === false) {
+        frontmatter.copilot = false;
+    }
+    else {
+        const copilotConfig = isObject(explicitCopilot)
+            ? cloneUnknown(explicitCopilot)
+            : {};
+        for (const [key, value] of Object.entries(inferredCopilotConfig)) {
+            if (!(key in copilotConfig)) {
+                copilotConfig[key] = value;
+            }
+        }
+        if (Object.keys(copilotConfig).length > 0) {
+            frontmatter.copilot = copilotConfig;
+        }
+    }
+    return {
+        name,
+        description,
+        body: parsed.content.trimStart(),
+        frontmatter: frontmatter,
+        sourcePath,
+        fileName,
+    };
+}
+function normalizeGitHubPromptForImport(command) {
+    const fileName = toCanonicalCommandFileName(command.fileName);
+    if (!command.frontmatter) {
+        return {
+            ...command,
+            fileName,
+        };
+    }
+    const nextFrontmatter = {};
+    for (const provider of ALL_PROVIDERS) {
+        if (provider === "copilot")
+            continue;
+        const value = command.frontmatter[provider];
+        if (value === false || isObject(value)) {
+            nextFrontmatter[provider] = cloneUnknown(value);
+        }
+    }
+    const explicitCopilot = command.frontmatter.copilot;
+    if (explicitCopilot === false) {
+        nextFrontmatter.copilot = false;
+    }
+    else {
+        const copilotConfig = isObject(explicitCopilot)
+            ? cloneUnknown(explicitCopilot)
+            : {};
+        for (const [key, value] of Object.entries(command.frontmatter)) {
+            if (ALL_PROVIDERS.includes(key))
+                continue;
+            if (!(key in copilotConfig)) {
+                copilotConfig[key] = cloneUnknown(value);
+            }
+        }
+        if (Object.keys(copilotConfig).length > 0) {
+            nextFrontmatter.copilot = copilotConfig;
+        }
+    }
+    const frontmatter = Object.keys(nextFrontmatter).length > 0 ? nextFrontmatter : undefined;
+    const body = normalizeCommandArgumentsForCanonical(command.body, "copilot").trimStart();
+    return {
+        ...command,
+        fileName,
+        body,
+        frontmatter,
+        content: buildCommandMarkdownForImport(frontmatter, body),
+    };
+}
+function normalizeGeminiCommandForImport(command) {
+    const fileName = toCanonicalCommandFileName(command.fileName);
+    const body = normalizeCommandArgumentsForCanonical(command.body, "gemini");
+    if (!command.frontmatter) {
+        return {
+            ...command,
+            fileName,
+            body,
+            content: buildCommandMarkdownForImport(undefined, body),
+        };
+    }
+    const nextFrontmatter = {};
+    for (const provider of ALL_PROVIDERS) {
+        if (provider === "gemini")
+            continue;
+        const value = command.frontmatter[provider];
+        if (value === false || isObject(value)) {
+            nextFrontmatter[provider] = cloneUnknown(value);
+        }
+    }
+    if (typeof command.frontmatter.description === "string") {
+        nextFrontmatter.description = command.frontmatter.description;
+    }
+    const explicitGemini = command.frontmatter.gemini;
+    if (explicitGemini === false) {
+        nextFrontmatter.gemini = false;
+    }
+    else {
+        const geminiConfig = isObject(explicitGemini)
+            ? cloneUnknown(explicitGemini)
+            : {};
+        for (const [key, value] of Object.entries(command.frontmatter)) {
+            if (key === "description")
+                continue;
+            if (ALL_PROVIDERS.includes(key))
+                continue;
+            if (!(key in geminiConfig)) {
+                geminiConfig[key] = cloneUnknown(value);
+            }
+        }
+        if (Object.keys(geminiConfig).length > 0) {
+            nextFrontmatter.gemini = geminiConfig;
+        }
+    }
+    const frontmatter = Object.keys(nextFrontmatter).length > 0 ? nextFrontmatter : undefined;
+    return {
+        ...command,
+        fileName,
+        body,
+        frontmatter,
+        content: buildCommandMarkdownForImport(frontmatter, body),
+    };
+}
+function buildCommandMarkdownForImport(frontmatter, body) {
+    if (!frontmatter) {
+        return body.endsWith("\n") ? body : `${body}\n`;
+    }
+    const fm = YAML.stringify(frontmatter, { lineWidth: 0 }).trimEnd();
+    return `---\n${fm}\n---\n\n${body}${body.endsWith("\n") ? "" : "\n"}`;
+}
+function inferAgentNameFromFile(fileName) {
+    const base = fileName
+        .replace(/\.agent\.md$/i, "")
+        .replace(/\.md$/i, "")
+        .trim();
+    return base || "agent";
+}
+function toCanonicalCommandFileName(fileName) {
+    const lower = fileName.toLowerCase();
+    if (lower.endsWith(".prompt.md")) {
+        return `${fileName.slice(0, -".prompt.md".length)}.md`;
+    }
+    if (lower.endsWith(".toml")) {
+        return `${fileName.slice(0, -".toml".length)}.md`;
+    }
+    return fileName;
+}
+function cloneUnknown(value) {
+    return JSON.parse(JSON.stringify(value));
+}
 async function resolveAgentsToImport(options) {
     const requestedAgents = normalizeRequestedAgents(options.requestedAgents);
     if (requestedAgents && requestedAgents.length > 0) {
@@ -653,7 +1299,8 @@ function findMatchingLockEntry(entries, key) {
         sameRequestedAgentsForMatch(entry.requestedAgents, key.requestedAgents) &&
         sameStringSelectionForMatch(entry.selectedSourceCommands, key.selectedSourceCommands) &&
         sameStringSelectionForMatch(entry.selectedSourceMcpServers, key.selectedSourceMcpServers) &&
-        sameStringSelectionForMatch(entry.selectedSourceSkills, key.selectedSourceSkills, { wildcardWhenRightIsUndefined: true }) &&
+        sameStringSelectionForMatch(entry.selectedSourceRules, key.selectedSourceRules, { wildcardWhenRightIsUndefined: true }) &&
+        sameSkillSelectionForMatch(entry.selectedSourceSkills, key.selectedSourceSkills, key.selectedSkills, { wildcardWhenRightIsUndefined: true }) &&
         sameStringSelectionForMatch(entry.skillsProviders, key.skillsProviders, {
             wildcardWhenRightIsUndefined: true,
         }));
@@ -667,6 +1314,7 @@ function findRelaxedCommandEntry(entries, key) {
         return undefined;
     const mixed = matches.find((entry) => entry.importedAgents.length > 0 ||
         entry.importedMcpServers.length > 0 ||
+        entry.importedRules.length > 0 ||
         entry.importedSkills.length > 0);
     return mixed ?? matches[0];
 }
@@ -696,6 +1344,39 @@ function sameStringSelectionForMatch(left, right, options = {}) {
     }
     return normalizedLeft.every((value, index) => value === normalizedRight[index]);
 }
+function sameSkillSelectionForMatch(left, right, selectedSkills, options = {}) {
+    if (options.wildcardWhenRightIsUndefined && right === undefined) {
+        return true;
+    }
+    const normalizedLeft = normalizeSkillSelectionsForMatch(left);
+    const normalizedRight = normalizeSkillSelectionsForMatch(right);
+    if (normalizedLeft.length === normalizedRight.length &&
+        normalizedLeft.every((value, index) => value === normalizedRight[index])) {
+        return true;
+    }
+    if (!selectedSkills || normalizedLeft.length !== selectedSkills.length) {
+        return false;
+    }
+    const remainingSelectors = new Set(normalizedLeft);
+    for (const skill of selectedSkills) {
+        const matchedSelector = [
+            normalizeSkillSelector(skill.name),
+            normalizeSkillSelector(skill.sourceDirName),
+        ].find((selector) => selector && remainingSelectors.has(selector));
+        if (!matchedSelector) {
+            return false;
+        }
+        remainingSelectors.delete(matchedSelector);
+    }
+    return remainingSelectors.size === 0;
+}
+function normalizeSkillSelectionsForMatch(value) {
+    if (!Array.isArray(value) || value.length === 0)
+        return [];
+    return [
+        ...new Set(value.map((item) => normalizeSkillSelector(item)).filter(Boolean)),
+    ].sort();
+}
 function uniqueStrings(values) {
     return [...new Set(values)];
 }
@@ -714,6 +1395,11 @@ function computeTrackedEntitiesForLock(options) {
         (options.selectedSourceMcpServers?.length ?? 0) > 0) {
         tracked.push("mcp");
     }
+    if (options.importedRules.length > 0 ||
+        (options.selectedSourceRules?.length ?? 0) > 0 ||
+        Object.keys(options.ruleRenameMap ?? {}).length > 0) {
+        tracked.push("rule");
+    }
     if (options.importedSkills.length > 0 ||
         (options.selectedSourceSkills?.length ?? 0) > 0 ||
         (options.skillsProviders?.length ?? 0) > 0 ||
@@ -754,6 +1440,44 @@ function resolveMappedTargetFileName(sourceFileName, renameMap) {
     }
     return undefined;
 }
+function normalizeRuleRenameMap(renameMap) {
+    if (!renameMap)
+        return undefined;
+    const normalizedEntries = Object.entries(renameMap)
+        .map(([sourceSelector, importedName]) => {
+        const normalizedSourceSelector = normalizeRuleSelector(sourceSelector);
+        const importedBaseName = path.basename(importedName.trim());
+        if (!normalizedSourceSelector || !importedBaseName) {
+            return null;
+        }
+        const ext = path.extname(importedBaseName);
+        const stem = stripRuleFileExtension(importedBaseName);
+        const normalizedTarget = `${slugify(stem) || "rule"}${ext || ".md"}`;
+        return [normalizedSourceSelector, normalizedTarget];
+    })
+        .filter((entry) => entry !== null);
+    if (normalizedEntries.length === 0)
+        return undefined;
+    return Object.fromEntries(normalizedEntries);
+}
+function resolveMappedTargetRuleFileName(sourceFileName, renameMap) {
+    if (!renameMap)
+        return undefined;
+    const normalizedSourceName = normalizeRuleSelector(sourceFileName);
+    for (const [sourceSelector, importedName] of Object.entries(renameMap)) {
+        if (normalizeRuleSelector(sourceSelector) !== normalizedSourceName) {
+            continue;
+        }
+        const importedBaseName = path.basename(importedName.trim());
+        if (!importedBaseName)
+            return undefined;
+        const ext = path.extname(importedBaseName);
+        if (ext)
+            return importedBaseName;
+        return `${slugify(importedBaseName) || "rule"}.md`;
+    }
+    return undefined;
+}
 function normalizeSkillRenameMap(renameMap) {
     if (!renameMap)
         return undefined;
@@ -771,20 +1495,65 @@ function normalizeSkillRenameMap(renameMap) {
         return undefined;
     return Object.fromEntries(normalizedEntries);
 }
-function resolveMappedTargetSkillName(sourceSkillName, renameMap) {
+function resolveMappedTargetSkillName(sourceSkill, selectedSkills, renameMap) {
     if (!renameMap)
         return undefined;
-    const normalizedSourceName = normalizeSkillSelector(sourceSkillName);
-    if (!normalizedSourceName)
-        return undefined;
     for (const [sourceSelector, importedName] of Object.entries(renameMap)) {
-        if (normalizeSkillSelector(sourceSelector) !== normalizedSourceName) {
+        const matchedSkill = resolveSkillSelector(selectedSkills, sourceSelector);
+        if (!matchedSkill || matchedSkill.sourcePath !== sourceSkill.sourcePath) {
             continue;
         }
         return slugify(path.basename(importedName.trim())) || "skill";
     }
     return undefined;
 }
+function moveLegacySkillDirectoryToCanonicalIfUnchanged(options) {
+    if (options.legacySkillDirName === options.canonicalSkillDirName) {
+        return;
+    }
+    const legacySkillDir = path.join(options.paths.skillsDir, options.legacySkillDirName);
+    if (!fs.existsSync(legacySkillDir) ||
+        !fs.statSync(legacySkillDir).isDirectory()) {
+        return;
+    }
+    const canonicalSkillDir = path.join(options.paths.skillsDir, options.canonicalSkillDirName);
+    if (fs.existsSync(canonicalSkillDir)) {
+        return;
+    }
+    if (!skillContentMatchesTarget(options.sourceSkill, legacySkillDir)) {
+        return;
+    }
+    moveDirectory(legacySkillDir, canonicalSkillDir);
+}
+function removeLegacySkillDirectory(options) {
+    if (options.legacySkillDirName === options.canonicalSkillDirName) {
+        return;
+    }
+    const legacySkillDir = path.join(options.paths.skillsDir, options.legacySkillDirName);
+    if (!fs.existsSync(legacySkillDir)) {
+        return;
+    }
+    const stat = fs.lstatSync(legacySkillDir);
+    if (!stat.isDirectory() || stat.isSymbolicLink()) {
+        return;
+    }
+    fs.rmSync(legacySkillDir, { recursive: true, force: true });
+}
+function moveDirectory(sourceDir, targetDir) {
+    ensureDir(path.dirname(targetDir));
+    try {
+        fs.renameSync(sourceDir, targetDir);
+        return;
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code !== "EXDEV") {
+            throw error;
+        }
+    }
+    fs.cpSync(sourceDir, targetDir, { recursive: true, force: true });
+    fs.rmSync(sourceDir, { recursive: true, force: true });
+}
 function normalizeSkillsProviders(providers) {
     if (!providers || providers.length === 0)
         return undefined;
@@ -799,12 +1568,13 @@ function normalizeSkillsProviders(providers) {
 }
 async function resolveSkillConflict(options) {
     const targetPath = path.join(options.paths.skillsDir, options.targetSkillDirName);
-    if (!fs.existsSync(targetPath))
+    const conflictPath = resolveExistingSkillConflictPath(options, targetPath);
+    if (!conflictPath)
         return options.targetSkillDirName;
-    if (!fs.statSync(targetPath).isDirectory()) {
-        throw new Error(`Cannot import skill ${options.promptLabel}: ${targetPath} exists and is not a directory.`);
+    if (!fs.statSync(conflictPath).isDirectory()) {
+        throw new Error(`Cannot import skill ${options.promptLabel}: ${conflictPath} exists and is not a directory.`);
     }
-    if (skillContentMatchesTarget(options.sourceSkill, targetPath)) {
+    if (skillContentMatchesTarget(options.sourceSkill, conflictPath)) {
         return options.targetSkillDirName;
     }
     if (options.yes) {
@@ -851,6 +1621,17 @@ async function resolveSkillConflict(options) {
     }
     return options.targetSkillDirName;
 }
+function resolveExistingSkillConflictPath(options, targetPath) {
+    if (fs.existsSync(targetPath)) {
+        return targetPath;
+    }
+    if (!options.legacySkillDirName ||
+        options.legacySkillDirName === options.canonicalSkillDirName) {
+        return null;
+    }
+    const legacyPath = path.join(options.paths.skillsDir, options.legacySkillDirName);
+    return fs.existsSync(legacyPath) ? legacyPath : null;
+}
 async function resolveAgentConflict(options) {
     const targetPath = path.join(options.paths.agentsDir, options.targetFileName);
     if (!fs.existsSync(targetPath))
@@ -954,6 +1735,58 @@ async function resolveCommandConflict(options) {
     }
     return options.targetFileName;
 }
+async function resolveRuleConflict(options) {
+    const targetPath = path.join(options.paths.rulesDir, options.targetFileName);
+    if (!fs.existsSync(targetPath))
+        return options.targetFileName;
+    const existing = fs.readFileSync(targetPath, "utf8");
+    if (existing === options.ruleContent)
+        return options.targetFileName;
+    if (options.yes) {
+        return options.targetFileName;
+    }
+    if (options.nonInteractive) {
+        throw new NonInteractiveConflictError(`Conflict for ${options.targetFileName}. Use --yes or run interactively.`);
+    }
+    const choice = await select({
+        message: `Rule conflict for ${options.promptLabel}`,
+        options: [
+            { value: "overwrite", label: `Overwrite ${options.targetFileName}` },
+            { value: "skip", label: "Skip this rule" },
+            { value: "rename", label: "Rename imported rule" },
+        ],
+    });
+    if (isCancel(choice)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    if (choice === "skip")
+        return null;
+    if (choice === "rename") {
+        const entered = await promptText({
+            message: `New filename (without extension) for ${options.promptLabel}`,
+            placeholder: options.targetFileName.replace(/\.(md|mdc)$/i, ""),
+            validate(value) {
+                if (!value.trim())
+                    return "Name is required.";
+                if (/[\\/]/.test(value))
+                    return "Use a simple filename.";
+                return undefined;
+            },
+        });
+        if (isCancel(entered)) {
+            cancel("Operation cancelled.");
+            process.exit(1);
+        }
+        const extension = path.extname(options.targetFileName) || ".md";
+        const renamedFileName = `${slugify(String(entered)) || "rule"}${extension}`;
+        return resolveRuleConflict({
+            ...options,
+            targetFileName: renamedFileName,
+        });
+    }
+    return options.targetFileName;
+}
 async function resolveCommandsToImport(options) {
     const selectors = options.selectors
         .map((selector) => selector.trim())
@@ -1073,6 +1906,62 @@ async function resolveMcpServersToImport(options) {
         selectionMode,
     };
 }
+async function resolveRulesToImport(options) {
+    const selectors = options.selectors
+        .map((selector) => selector.trim())
+        .filter(Boolean);
+    if (selectors.length > 0) {
+        const { selected, unmatched } = resolveRuleSelections(options.sourceRules, selectors);
+        if (unmatched.length > 0) {
+            throw new Error(`Rule(s) not found in source: ${unmatched.join(", ")}. Available: ${options.sourceRules.map((item) => item.fileName).join(", ")}`);
+        }
+        return {
+            selectedRules: selected,
+            selectionMode: "custom",
+        };
+    }
+    const selectionResolution = await resolveSelectionModeWithSkip({
+        entityLabel: "rules",
+        selectionMode: options.selectionMode,
+        promptForSelection: options.promptForRules,
+        nonInteractive: options.nonInteractive,
+    });
+    const selectionMode = selectionResolution.selectionMode;
+    if (selectionResolution.skipImport) {
+        return {
+            selectedRules: [],
+            selectionMode: "custom",
+        };
+    }
+    if (selectionMode === "all" ||
+        !options.promptForRules ||
+        options.nonInteractive) {
+        return {
+            selectedRules: options.sourceRules,
+            selectionMode,
+        };
+    }
+    const selected = await multiselect({
+        message: withMultiselectHelp("Select rules to import"),
+        options: options.sourceRules.map((item) => ({
+            value: item.fileName,
+            label: item.fileName,
+            hint: item.name,
+        })),
+        initialValues: options.sourceRules.map((item) => item.fileName),
+    });
+    if (isCancel(selected)) {
+        cancel("Operation cancelled.");
+        process.exit(1);
+    }
+    const selectedNames = Array.isArray(selected)
+        ? new Set(selected.map((value) => String(value)))
+        : new Set();
+    return {
+        selectedRules: options.sourceRules.filter((item) => selectedNames.has(item.fileName)),
+        selectionMode,
+    };
+}
 async function resolveSkillsToImport(options) {
     const selectors = options.selectors
         .map((item) => item.trim())
@@ -1084,6 +1973,7 @@ async function resolveSkillsToImport(options) {
         }
         return {
             selectedSkills: selected,
+            selectedSourceSkills: selectors,
             selectionMode: "custom",
         };
     }
@@ -1097,6 +1987,7 @@ async function resolveSkillsToImport(options) {
     if (selectionResolution.skipImport) {
         return {
             selectedSkills: [],
+            selectedSourceSkills: [],
             selectionMode: "custom",
         };
     }
@@ -1105,6 +1996,7 @@ async function resolveSkillsToImport(options) {
         options.nonInteractive) {
         return {
             selectedSkills: options.sourceSkills,
+            selectedSourceSkills: options.sourceSkills.map((skill) => skill.name),
             selectionMode,
         };
     }
@@ -1125,6 +2017,9 @@ async function resolveSkillsToImport(options) {
         : new Set();
     return {
         selectedSkills: options.sourceSkills.filter((skill) => selectedNames.has(skill.name)),
+        selectedSourceSkills: options.sourceSkills
+            .filter((skill) => selectedNames.has(skill.name))
+            .map((skill) => skill.name),
         selectionMode,
     };
 }