agentloom 0.1.4 → 0.1.6

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 { normalizeCommandArgumentsForCanonical, normalizeCommandSelector, parseCommandsDir, resolveCommandSelections, } from "./commands.js";
+import { normalizeRuleSelector, parseRulesDir, resolveRuleSelections, stripRuleFileExtension, } from "./rules.js";
 import { applySkillProviderSideEffects, copySkillArtifacts, normalizeSkillSelector, parseSkillsDir, resolveSkillSelections, skillContentMatchesTarget, } from "./skills.js";
-import { ensureDir, hashContent, readJsonIfExists, relativePosix, slugify, writeTextAtomic, } from "./fs.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 { discoverSourceAgentsDir, discoverSourceCommandsDir, discoverSourceCommandsDirs, discoverSourceMcpPath, discoverSourceRulesDir, discoverSourceSkillsDir, 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.");
     }
@@ -46,36 +54,47 @@ export async function importSource(options) {
         const sourceAgentsDir = shouldImportAgents
             ? discoverSourceAgentsDir(prepared.importRoot)
             : null;
-        const sourceCommandsDir = shouldImportCommands
-            ? discoverSourceCommandsDir(prepared.importRoot)
-            : null;
+        const sourceCommandsDirs = shouldImportCommands
+            ? discoverSourceCommandsDirs(prepared.importRoot)
+            : [];
+        const sourceCommandsDir = sourceCommandsDirs[0] ??
+            (shouldImportCommands
+                ? discoverSourceCommandsDir(prepared.importRoot)
+                : null);
         const sourceMcpPath = shouldImportMcp
             ? discoverSourceMcpPath(prepared.importRoot)
             : null;
+        const sourceRulesDir = shouldImportRules
+            ? discoverSourceRulesDir(prepared.importRoot)
+            : null;
         const sourceSkillsDir = shouldImportSkills
             ? discoverSourceSkillsDir(prepared.importRoot)
             : null;
-        const sourceAgents = sourceAgentsDir ? parseAgentsDir(sourceAgentsDir) : [];
-        const sourceCommands = sourceCommandsDir
-            ? parseCommandsDir(sourceCommandsDir)
+        const sourceAgents = sourceAgentsDir
+            ? parseSourceAgentsForImport(sourceAgentsDir)
+            : [];
+        const sourceCommands = sourceCommandsDirs.length > 0
+            ? parseSourceCommandsForImport(sourceCommandsDirs)
             : [];
         const sourceMcp = sourceMcpPath
             ? normalizeMcp(readJsonIfExists(sourceMcpPath))
             : null;
+        const sourceRules = sourceRulesDir ? parseRulesDir(sourceRulesDir) : [];
         const sourceSkills = sourceSkillsDir ? parseSkillsDir(sourceSkillsDir) : [];
         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/).`);
+            throw new Error(`No source agents directory found under ${prepared.importRoot} (expected agents/, .agents/agents/, or .github/agents/).`);
         }
         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/).`);
+            throw new Error(`No source commands directory found under ${prepared.importRoot} (expected .agents/commands/, commands/, prompts/, .gemini/commands/, or .github/prompts/).`);
         }
         if (shouldImportCommands &&
             options.requireCommands &&
@@ -85,6 +104,12 @@ export async function importSource(options) {
         if (shouldImportMcp && options.requireMcp && !sourceMcpPath) {
             throw new Error(`No source mcp.json found under ${prepared.importRoot} (expected mcp.json or .agents/mcp.json).`);
         }
+        if (shouldImportRules && requireRules && !sourceRulesDir) {
+            throw new Error(`No source rules directory found under ${prepared.importRoot} (expected .agents/rules/ or rules/).`);
+        }
+        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).`);
         }
@@ -96,9 +121,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/, or root SKILL.md.`);
         }
         const shouldResolveAgents = shouldImportAgents &&
             (sourceAgents.length > 0 ||
@@ -145,6 +171,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";
@@ -240,6 +281,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 = {};
@@ -258,7 +340,8 @@ export async function importSource(options) {
                     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({
@@ -303,10 +386,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 +399,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 +409,7 @@ export async function importSource(options) {
         const isCommandOnlyImport = !shouldImportAgents &&
             shouldImportCommands &&
             !shouldImportMcp &&
+            !shouldImportRules &&
             !shouldImportSkills;
         const existingEntry = isCommandOnlyImport
             ? findRelaxedCommandEntry(lockfile.entries, {
@@ -338,6 +427,7 @@ export async function importSource(options) {
                     : options.agents,
                 selectedSourceCommands: selectedSourceCommandsForLock,
                 selectedSourceMcpServers: selectedSourceMcpServersForLock,
+                selectedSourceRules: selectedSourceRulesForLock,
                 selectedSourceSkills: selectedSourceSkillsForLock,
                 skillsProviders: skillsProvidersForLock,
             });
@@ -360,6 +450,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 +485,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 +527,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 +542,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 +565,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 +594,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 +605,357 @@ export async function importSource(options) {
         prepared.cleanup();
     }
 }
+function parseSourceAgentsForImport(sourceAgentsDir) {
+    if (isGitHubAgentsDir(sourceAgentsDir)) {
+        return parseGitHubAgentsDirForImport(sourceAgentsDir);
+    }
+    return parseAgentsDir(sourceAgentsDir);
+}
+function parseSourceCommandsForImport(sourceCommandsDir) {
+    const sourceCommandsDirs = Array.isArray(sourceCommandsDir)
+        ? sourceCommandsDir
+        : [sourceCommandsDir];
+    return mergeCanonicalCommandFiles(sourceCommandsDirs.flatMap((dirPath) => parseSourceCommandsFromDir(dirPath)));
+}
+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,6 +1116,7 @@ function findMatchingLockEntry(entries, key) {
         sameRequestedAgentsForMatch(entry.requestedAgents, key.requestedAgents) &&
         sameStringSelectionForMatch(entry.selectedSourceCommands, key.selectedSourceCommands) &&
         sameStringSelectionForMatch(entry.selectedSourceMcpServers, key.selectedSourceMcpServers) &&
+        sameStringSelectionForMatch(entry.selectedSourceRules, key.selectedSourceRules, { wildcardWhenRightIsUndefined: true }) &&
         sameStringSelectionForMatch(entry.selectedSourceSkills, key.selectedSourceSkills, { wildcardWhenRightIsUndefined: true }) &&
         sameStringSelectionForMatch(entry.skillsProviders, key.skillsProviders, {
             wildcardWhenRightIsUndefined: true,
@@ -667,6 +1131,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];
 }
@@ -714,6 +1179,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 +1224,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;
@@ -954,6 +1462,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 +1633,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())