agentloom 0.1.4 → 0.1.6

package/dist/commands/find.js

@@ -6,6 +6,7 @@ import { parseAgentMarkdown, parseAgentsDir } from "../core/agents.js";
 import { parseCommandsDir } from "../core/commands.js";
 import { formatUsageError, getFindHelpText } from "../core/copy.js";
 import { readCanonicalMcp } from "../core/mcp.js";
+import { parseRulesDir } from "../core/rules.js";
 import { buildScopePaths } from "../core/scope.js";
 import { parseSkillsDir } from "../core/skills.js";
 const FIND_API_BASE = process.env.AGENTLOOM_FIND_API_BASE || "https://api.github.com";
@@ -34,6 +35,7 @@ export async function runScopedFindCommand(argv, target, searchClient = searchAg
     const shouldSearchAgents = target === "all" || target === "agent";
     const shouldSearchCommands = target === "all" || target === "command";
     const shouldSearchMcp = target === "all" || target === "mcp";
+    const shouldSearchRules = target === "all" || target === "rule";
     const shouldSearchSkills = target === "all" || target === "skill";
     const agentResult = shouldSearchAgents
         ? normalizeSearchResult(await searchClient(query, DEFAULT_RESULT_LIMIT))
@@ -44,6 +46,9 @@ export async function runScopedFindCommand(argv, target, searchClient = searchAg
     const mcpResult = shouldSearchMcp
         ? await searchMcpWithDiagnostics(query, DEFAULT_RESULT_LIMIT, FIND_API_BASE)
         : { items: [], failures: [] };
+    const ruleResult = shouldSearchRules
+        ? await searchRulesWithDiagnostics(query, DEFAULT_RESULT_LIMIT, FIND_API_BASE)
+        : { items: [], failures: [] };
     const skillResult = shouldSearchSkills
         ? await searchSkillsWithDiagnostics(query, DEFAULT_RESULT_LIMIT, FIND_API_BASE)
         : { items: [], failures: [] };
@@ -85,12 +90,14 @@ export async function runScopedFindCommand(argv, target, searchClient = searchAg
     const total = agentResult.agents.length +
         commandResult.items.length +
         mcpResult.items.length +
+        ruleResult.items.length +
         skillResult.items.length +
         local.total;
     if (total === 0) {
         const failureCount = agentResult.failures.length +
             commandResult.failures.length +
             mcpResult.failures.length +
+            ruleResult.failures.length +
             skillResult.failures.length;
         if (failureCount > 0) {
             throw new Error(`Search returned no results and encountered ${failureCount} remote scan failure(s).`);
@@ -134,6 +141,15 @@ export async function runScopedFindCommand(argv, target, searchClient = searchAg
         }
         console.log("");
     }
+    if (ruleResult.items.length > 0) {
+        console.log("Rule matches:");
+        for (const result of ruleResult.items) {
+            console.log(`  - ${result.repo}@${result.ruleName}${formatStars(result.stars)} (${result.filePath})`);
+            console.log(`    ${result.fileUrl}`);
+            console.log(`    Install: ${buildRuleInstallCommand(result)}`);
+        }
+        console.log("");
+    }
     if (skillResult.items.length > 0) {
         console.log("Skill matches:");
         for (const result of skillResult.items) {
@@ -147,6 +163,7 @@ export async function runScopedFindCommand(argv, target, searchClient = searchAg
         ...agentResult.failures,
         ...commandResult.failures,
         ...mcpResult.failures,
+        ...ruleResult.failures,
         ...skillResult.failures,
     ];
     if (failures.length > 0) {
@@ -351,6 +368,42 @@ async function searchSkillsWithDiagnostics(query, limit, apiBase) {
     }));
     return normalizeEntityScanResults(scanned, limit);
 }
+async function searchRulesWithDiagnostics(query, limit, apiBase) {
+    const tokens = tokenizeQuery(query);
+    const repos = await searchReposByQuery(query, apiBase);
+    const candidates = repos.slice(0, DEFAULT_REPO_SCAN_LIMIT);
+    const scanned = await Promise.allSettled(candidates.map(async (repo) => {
+        const tree = await getRepoTree(repo, apiBase);
+        const matches = [];
+        for (const entry of tree) {
+            if (entry.type !== "blob")
+                continue;
+            const filePath = toTrimmedString(entry.path);
+            if (!filePath)
+                continue;
+            const parsed = parseRulePath(filePath);
+            if (!parsed)
+                continue;
+            const haystack = `${repo.fullName} ${filePath} ${parsed.ruleName}`.toLowerCase();
+            if (tokens.length > 0 &&
+                !tokens.some((token) => haystack.includes(token))) {
+                continue;
+            }
+            matches.push({
+                repo: repo.fullName,
+                ruleName: parsed.ruleName,
+                installRuleSelector: parsed.installRuleSelector,
+                filePath,
+                fileUrl: `${repo.repoWebUrl}/blob/${repo.defaultBranch}/${filePath}`,
+                source: repo.installSource,
+                stars: repo.stars,
+                subdir: parsed.subdir,
+            });
+        }
+        return matches;
+    }));
+    return normalizeEntityScanResults(scanned, limit);
+}
 async function searchReposByQuery(query, apiBase) {
     const url = buildApiUrl(apiBase, "search/repositories");
     url.searchParams.set("q", `${query} in:name,description,readme`);
@@ -433,6 +486,17 @@ async function getRepoTree(repo, apiBase) {
     return payload.tree;
 }
 function parseAgentPath(filePath) {
+    const directGitHub = filePath.match(/^\.github\/agents\/([^/]+)\.agent\.md$/i);
+    if (directGitHub) {
+        return { agentName: directGitHub[1] };
+    }
+    const nestedGitHub = filePath.match(/^(.+)\/\.github\/agents\/([^/]+)\.agent\.md$/i);
+    if (nestedGitHub) {
+        return {
+            subdir: nestedGitHub[1],
+            agentName: nestedGitHub[2],
+        };
+    }
     const directAgentloom = filePath.match(/^\.agents\/agents\/([^/]+)\.md$/);
     if (directAgentloom) {
         return { agentName: directAgentloom[1] };
@@ -458,41 +522,55 @@ function parseAgentPath(filePath) {
     return null;
 }
 function parseCommandPath(filePath) {
-    const directAgentloom = filePath.match(/^\.agents\/commands\/([^/]+)\.(md|mdc)$/i);
+    const directGitHub = filePath.match(/^\.github\/prompts\/([^/]+)\.prompt\.md$/i);
+    if (directGitHub) {
+        return { commandName: stripPromptSuffix(directGitHub[1]) };
+    }
+    const nestedGitHub = filePath.match(/^(.+)\/\.github\/prompts\/([^/]+)\.prompt\.md$/i);
+    if (nestedGitHub) {
+        return {
+            subdir: nestedGitHub[1],
+            commandName: stripPromptSuffix(nestedGitHub[2]),
+        };
+    }
+    const directAgentloom = filePath.match(/^\.agents\/commands\/([^/]+)(?:\.prompt)?\.(md|mdc)$/i);
     if (directAgentloom) {
-        return { commandName: directAgentloom[1] };
+        return { commandName: stripPromptSuffix(directAgentloom[1]) };
     }
-    const nestedAgentloom = filePath.match(/^(.+)\/\.agents\/commands\/([^/]+)\.(md|mdc)$/i);
+    const nestedAgentloom = filePath.match(/^(.+)\/\.agents\/commands\/([^/]+)(?:\.prompt)?\.(md|mdc)$/i);
     if (nestedAgentloom) {
         return {
             subdir: nestedAgentloom[1],
-            commandName: nestedAgentloom[2],
+            commandName: stripPromptSuffix(nestedAgentloom[2]),
         };
     }
-    const directCommands = filePath.match(/^commands\/([^/]+)\.(md|mdc)$/i);
+    const directCommands = filePath.match(/^commands\/([^/]+)(?:\.prompt)?\.(md|mdc)$/i);
     if (directCommands) {
-        return { commandName: directCommands[1] };
+        return { commandName: stripPromptSuffix(directCommands[1]) };
     }
-    const nestedCommands = filePath.match(/^(.+)\/commands\/([^/]+)\.(md|mdc)$/i);
+    const nestedCommands = filePath.match(/^(.+)\/commands\/([^/]+)(?:\.prompt)?\.(md|mdc)$/i);
     if (nestedCommands) {
         return {
             subdir: nestedCommands[1],
-            commandName: nestedCommands[2],
+            commandName: stripPromptSuffix(nestedCommands[2]),
         };
     }
-    const directPrompts = filePath.match(/^prompts\/([^/]+)\.(md|mdc)$/i);
+    const directPrompts = filePath.match(/^prompts\/([^/]+)(?:\.prompt)?\.(md|mdc)$/i);
     if (directPrompts) {
-        return { commandName: directPrompts[1] };
+        return { commandName: stripPromptSuffix(directPrompts[1]) };
     }
-    const nestedPrompts = filePath.match(/^(.+)\/prompts\/([^/]+)\.(md|mdc)$/i);
+    const nestedPrompts = filePath.match(/^(.+)\/prompts\/([^/]+)(?:\.prompt)?\.(md|mdc)$/i);
     if (nestedPrompts) {
         return {
             subdir: nestedPrompts[1],
-            commandName: nestedPrompts[2],
+            commandName: stripPromptSuffix(nestedPrompts[2]),
         };
     }
     return null;
 }
+function stripPromptSuffix(commandName) {
+    return commandName.replace(/\.prompt$/i, "");
+}
 function parseSkillPath(filePath) {
     const directAgentloom = filePath.match(/^\.agents\/skills\/([^/]+)\/SKILL\.md$/i);
     if (directAgentloom) {
@@ -533,6 +611,39 @@ function parseSkillPath(filePath) {
     }
     return null;
 }
+function parseRulePath(filePath) {
+    const directCanonical = filePath.match(/^\.agents\/rules\/([^/]+)\.md$/i);
+    if (directCanonical) {
+        return {
+            ruleName: directCanonical[1],
+            installRuleSelector: directCanonical[1],
+        };
+    }
+    const nestedCanonical = filePath.match(/^(.+)\/\.agents\/rules\/([^/]+)\.md$/i);
+    if (nestedCanonical) {
+        return {
+            subdir: nestedCanonical[1],
+            ruleName: nestedCanonical[2],
+            installRuleSelector: nestedCanonical[2],
+        };
+    }
+    const directRules = filePath.match(/^rules\/([^/]+)\.md$/i);
+    if (directRules) {
+        return {
+            ruleName: directRules[1],
+            installRuleSelector: directRules[1],
+        };
+    }
+    const nestedRules = filePath.match(/^(.+)\/rules\/([^/]+)\.md$/i);
+    if (nestedRules) {
+        return {
+            subdir: nestedRules[1],
+            ruleName: nestedRules[2],
+            installRuleSelector: nestedRules[2],
+        };
+    }
+    return null;
+}
 function isMcpPath(filePath) {
     return (/^mcp\.json$/i.test(filePath) ||
         /^\.agents\/mcp\.json$/i.test(filePath) ||
@@ -701,6 +812,21 @@ function buildSkillInstallCommand(result) {
     }
     return `agentloom skill add ${repoArg} --skills ${quoteShellArg(selector)}`;
 }
+function buildRuleInstallCommand(result) {
+    const source = result.source?.trim() || result.repo;
+    const repoArg = quoteShellArg(source);
+    const selector = result.installRuleSelector?.trim();
+    if (result.subdir && result.subdir.trim()) {
+        if (!selector) {
+            return `agentloom rule add ${repoArg} --subdir ${quoteShellArg(result.subdir)}`;
+        }
+        return `agentloom rule add ${repoArg} --subdir ${quoteShellArg(result.subdir)} --rules ${quoteShellArg(selector)}`;
+    }
+    if (!selector) {
+        return `agentloom rule add ${repoArg}`;
+    }
+    return `agentloom rule add ${repoArg} --rules ${quoteShellArg(selector)}`;
+}
 function tokenizeQuery(query) {
     return query
         .toLowerCase()
@@ -749,6 +875,14 @@ function searchLocalMatches(query, target) {
             lines.push(`mcp: ${name}`);
         }
     }
+    if ((target === "all" || target === "rule") && fsExists(paths.rulesDir)) {
+        const rules = parseRulesDir(paths.rulesDir);
+        for (const rule of rules) {
+            if (!matchesTokens(`${rule.name} ${rule.fileName}`, tokens))
+                continue;
+            lines.push(`rule: ${rule.name} (${rule.fileName})`);
+        }
+    }
     if ((target === "all" || target === "skill") && fsExists(paths.skillsDir)) {
         const skills = parseSkillsDir(paths.skillsDir);
         for (const skill of skills) {

package/dist/commands/rule.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedArgs } from "minimist";
+export declare function runRuleCommand(argv: ParsedArgs, cwd: string): Promise<void>;

package/dist/commands/rule.js

@@ -0,0 +1,86 @@
+import { formatUsageError } from "../core/copy.js";
+import { parseRulesDir } from "../core/rules.js";
+import { runScopedAddCommand } from "./add.js";
+import { runScopedDeleteCommand } from "./delete.js";
+import { resolvePathsForCommand } from "./entity-utils.js";
+import { runScopedFindCommand } from "./find.js";
+import { runScopedSyncCommand } from "./sync.js";
+import { runScopedUpdateCommand } from "./update.js";
+export async function runRuleCommand(argv, cwd) {
+    const action = argv._[1];
+    if (argv.help || !action) {
+        console.log("Usage:\n  agentloom rule <add|list|delete|find|update|sync> [options]");
+        return;
+    }
+    if (action !== "add" &&
+        action !== "list" &&
+        action !== "delete" &&
+        action !== "find" &&
+        action !== "update" &&
+        action !== "sync") {
+        throw new Error(formatUsageError({
+            issue: "Invalid rule command.",
+            usage: "agentloom rule <add|list|delete|find|update|sync> [options]",
+            example: "agentloom rule add farnoodma/agents",
+        }));
+    }
+    if (action === "list") {
+        const paths = await resolvePathsForCommand(argv, cwd);
+        const rules = parseRulesDir(paths.rulesDir);
+        if (Boolean(argv.json)) {
+            console.log(JSON.stringify({
+                version: 1,
+                rules: rules.map((rule) => ({
+                    id: rule.id,
+                    name: rule.name,
+                    fileName: rule.fileName,
+                })),
+            }, null, 2));
+            return;
+        }
+        if (rules.length === 0) {
+            console.log("No canonical rules configured.");
+            return;
+        }
+        for (const rule of rules) {
+            console.log(`${rule.name} (${rule.fileName})`);
+        }
+        return;
+    }
+    if (action === "add") {
+        await runScopedAddCommand({
+            argv,
+            cwd,
+            entity: "rule",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    if (action === "delete") {
+        await runScopedDeleteCommand({
+            argv,
+            cwd,
+            entity: "rule",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    if (action === "find") {
+        await runScopedFindCommand(argv, "rule");
+        return;
+    }
+    if (action === "update") {
+        await runScopedUpdateCommand({
+            argv,
+            cwd,
+            entity: "rule",
+            sourceIndex: 2,
+        });
+        return;
+    }
+    await runScopedSyncCommand({
+        argv,
+        cwd,
+        target: "rule",
+    });
+}

package/dist/commands/sync.js

@@ -74,10 +74,18 @@ function createDryRunCanonicalPaths(paths) {
     const tempAgentsRoot = path.join(tempRoot, ".agents");
     if (fs.existsSync(paths.agentsRoot) &&
         fs.statSync(paths.agentsRoot).isDirectory()) {
-        fs.cpSync(paths.agentsRoot, tempAgentsRoot, {
-            recursive: true,
-            force: true,
-        });
+        try {
+            fs.cpSync(paths.agentsRoot, tempAgentsRoot, {
+                recursive: true,
+                force: true,
+            });
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== "ENOENT") {
+                throw error;
+            }
+        }
     }
     return {
         paths: {
@@ -85,6 +93,7 @@ function createDryRunCanonicalPaths(paths) {
             agentsRoot: tempAgentsRoot,
             agentsDir: path.join(tempAgentsRoot, "agents"),
             commandsDir: path.join(tempAgentsRoot, "commands"),
+            rulesDir: path.join(tempAgentsRoot, "rules"),
             skillsDir: path.join(tempAgentsRoot, "skills"),
             mcpPath: path.join(tempAgentsRoot, "mcp.json"),
             lockPath: path.join(tempAgentsRoot, "agents.lock.json"),

package/dist/commands/update.js

@@ -2,6 +2,7 @@ import path from "node:path";
 import { parseProvidersFlag } from "../core/argv.js";
 import { importSource, NonInteractiveConflictError } from "../core/importer.js";
 import { normalizeCommandSelector, stripCommandFileExtension, } from "../core/commands.js";
+import { normalizeRuleSelector, stripRuleFileExtension, } from "../core/rules.js";
 import { readLockfile } from "../core/lockfile.js";
 import { prepareSource, parseSourceSpec } from "../core/sources.js";
 import { getUpdateHelpText } from "../core/copy.js";
@@ -79,6 +80,7 @@ async function runEntityAwareUpdate(options) {
         if (!updatePlan.importAgents &&
             !updatePlan.importCommands &&
             !updatePlan.importMcp &&
+            !updatePlan.importRules &&
             !updatePlan.importSkills) {
             skipped += 1;
             continue;
@@ -92,6 +94,7 @@ async function runEntityAwareUpdate(options) {
                 promptForAgentSelection: false,
                 promptForCommands: false,
                 promptForMcp: false,
+                promptForRules: false,
                 promptForSkills: false,
                 yes: Boolean(options.argv.yes),
                 nonInteractive,
@@ -100,6 +103,7 @@ async function runEntityAwareUpdate(options) {
                 requireAgents: updatePlan.importAgents,
                 importCommands: updatePlan.importCommands,
                 importMcp: updatePlan.importMcp,
+                importRules: updatePlan.importRules,
             };
             if (updatePlan.importSkills) {
                 importOptions.importSkills = true;
@@ -120,6 +124,12 @@ async function runEntityAwareUpdate(options) {
             if (updatePlan.mcpSelectors) {
                 importOptions.mcpSelectors = updatePlan.mcpSelectors;
             }
+            if (updatePlan.ruleSelectors) {
+                importOptions.ruleSelectors = updatePlan.ruleSelectors;
+            }
+            if (updatePlan.ruleRenameMap) {
+                importOptions.ruleRenameMap = updatePlan.ruleRenameMap;
+            }
             if (updatePlan.skillSelectors) {
                 importOptions.skillSelectors = updatePlan.skillSelectors;
             }
@@ -152,19 +162,24 @@ function buildEntryUpdatePlan(entry, target) {
     const includeAgents = shouldUpdateEntity(entry, "agent", target);
     const includeCommands = shouldUpdateEntity(entry, "command", target);
     const includeMcp = shouldUpdateEntity(entry, "mcp", target);
+    const includeRules = shouldUpdateEntity(entry, "rule", target);
     const includeSkills = shouldUpdateEntity(entry, "skill", target);
     const commandOptions = getUpdateCommandOptions(entry, includeCommands);
     const mcpOptions = getUpdateMcpOptions(entry, includeMcp);
+    const ruleOptions = getUpdateRuleOptions(entry, includeRules);
     const skillOptions = getUpdateSkillOptions(entry, includeSkills);
     return {
         importAgents: includeAgents,
         importCommands: commandOptions.importCommands,
         importMcp: mcpOptions.importMcp,
+        importRules: ruleOptions.importRules,
         importSkills: skillOptions.importSkills,
         requestedAgents: includeAgents ? entry.requestedAgents : undefined,
         commandSelectors: commandOptions.commandSelectors,
         commandRenameMap: commandOptions.commandRenameMap,
         mcpSelectors: mcpOptions.mcpSelectors,
+        ruleSelectors: ruleOptions.ruleSelectors,
+        ruleRenameMap: ruleOptions.ruleRenameMap,
         skillSelectors: skillOptions.skillSelectors,
         skillsProviders: skillOptions.skillsProviders,
         skillRenameMap: skillOptions.skillRenameMap,
@@ -204,7 +219,7 @@ function shouldUpdateEntity(entry, entity, target) {
     if (target !== "all" && target !== entity)
         return false;
     if (target === "all" && !entry.trackedEntities) {
-        if (entity === "skill") {
+        if (entity === "skill" || entity === "rule") {
             return tracksEntity(entry, entity);
         }
         return true;
@@ -221,6 +236,9 @@ function tracksEntity(entry, entity) {
     const importedMcpServers = Array.isArray(entry.importedMcpServers)
         ? entry.importedMcpServers
         : [];
+    const importedRules = Array.isArray(entry.importedRules)
+        ? entry.importedRules
+        : [];
     const importedSkills = Array.isArray(entry.importedSkills)
         ? entry.importedSkills
         : [];
@@ -237,6 +255,11 @@ function tracksEntity(entry, entity) {
     if (entity === "mcp") {
         return (importedMcpServers.length > 0 || Boolean(entry.selectedSourceMcpServers));
     }
+    if (entity === "rule") {
+        return (importedRules.length > 0 ||
+            Boolean(entry.selectedSourceRules) ||
+            Boolean(entry.ruleRenameMap));
+    }
     return (importedSkills.length > 0 ||
         Boolean(entry.selectedSourceSkills) ||
         Boolean(entry.skillsProviders) ||
@@ -272,6 +295,26 @@ function getUpdateMcpOptions(entry, includeMcp) {
         mcpSelectors: entry.selectedSourceMcpServers,
     };
 }
+function getUpdateRuleOptions(entry, includeRules) {
+    if (!includeRules) {
+        return { importRules: false };
+    }
+    const ruleSelectors = getUpdateRuleSelectors(entry);
+    if (ruleSelectors && ruleSelectors.length === 0) {
+        return { importRules: false };
+    }
+    if (!ruleSelectors) {
+        return {
+            importRules: true,
+            ruleRenameMap: entry.ruleRenameMap,
+        };
+    }
+    return {
+        importRules: true,
+        ruleSelectors,
+        ruleRenameMap: getUpdateRuleRenameMap(entry, ruleSelectors),
+    };
+}
 function getUpdateSkillOptions(entry, includeSkills) {
     if (!includeSkills) {
         return { importSkills: false };
@@ -294,7 +337,11 @@ function getUpdateCommandSelectors(entry) {
     return undefined;
 }
 function getUpdateCommandRenameMap(entry, commandSelectors) {
-    const renameMapFromLock = filterRenameMapBySelectors(entry.commandRenameMap, commandSelectors);
+    const renameMapFromLock = filterRenameMapBySelectors({
+        renameMap: entry.commandRenameMap,
+        selectors: commandSelectors,
+        normalizeSelector: normalizeCommandSelector,
+    });
     if (renameMapFromLock) {
         return renameMapFromLock;
     }
@@ -319,12 +366,48 @@ function inferUpdateCommandRename(entry, commandSelectors) {
     }
     return importedName;
 }
-function filterRenameMapBySelectors(renameMap, selectors) {
-    if (!renameMap)
+function getUpdateRuleSelectors(entry) {
+    if (entry.selectedSourceRules !== undefined) {
+        return entry.selectedSourceRules;
+    }
+    return undefined;
+}
+function getUpdateRuleRenameMap(entry, ruleSelectors) {
+    const renameMapFromLock = filterRenameMapBySelectors({
+        renameMap: entry.ruleRenameMap,
+        selectors: ruleSelectors,
+        normalizeSelector: normalizeRuleSelector,
+    });
+    if (renameMapFromLock) {
+        return renameMapFromLock;
+    }
+    const inferredRename = inferUpdateRuleRename(entry, ruleSelectors);
+    if (!inferredRename)
+        return undefined;
+    return {
+        [ruleSelectors[0]]: inferredRename,
+    };
+}
+function inferUpdateRuleRename(entry, ruleSelectors) {
+    if (!ruleSelectors || ruleSelectors.length !== 1) {
+        return undefined;
+    }
+    if (entry.importedRules.length !== 1) {
+        return undefined;
+    }
+    const sourceName = stripRuleFileExtension(ruleSelectors[0]);
+    const importedName = stripRuleFileExtension(path.basename(entry.importedRules[0]));
+    if (!sourceName || !importedName || sourceName === importedName) {
+        return undefined;
+    }
+    return importedName;
+}
+function filterRenameMapBySelectors(options) {
+    if (!options.renameMap)
         return undefined;
-    const selectorSet = new Set(selectors.map(normalizeCommandSelector));
-    const filteredEntries = Object.entries(renameMap)
-        .filter(([sourceSelector]) => selectorSet.has(normalizeCommandSelector(sourceSelector)))
+    const selectorSet = new Set(options.selectors.map(options.normalizeSelector));
+    const filteredEntries = Object.entries(options.renameMap)
+        .filter(([sourceSelector]) => selectorSet.has(options.normalizeSelector(sourceSelector)))
         .map(([sourceSelector, importedFileName]) => [
         sourceSelector,
         path.basename(importedFileName),

package/dist/core/agents.js

@@ -46,7 +46,7 @@ export function parseAgentMarkdown(raw, sourcePath, fileName = path.basename(sou
     };
 }
 export function buildAgentMarkdown(frontmatter, body) {
-    const fm = YAML.stringify(frontmatter).trimEnd();
+    const fm = YAML.stringify(frontmatter, { lineWidth: 0 }).trimEnd();
     const normalizedBody = body.trimStart();
     return `---\n${fm}\n---\n\n${normalizedBody}${normalizedBody.endsWith("\n") ? "" : "\n"}`;
 }

package/dist/core/argv.js

@@ -14,6 +14,8 @@ export function parseArgs(argv) {
             "commands",
             "mcp",
             "mcps",
+            "rule",
+            "rules",
             "skill",
             "skills",
             "url",

package/dist/core/commands.d.ts

@@ -1,9 +1,21 @@
+import type { Provider } from "../types.js";
 export interface CanonicalCommandFile {
     fileName: string;
     sourcePath: string;
     content: string;
+    body: string;
+    frontmatter?: Record<string, unknown>;
 }
 export declare function parseCommandsDir(commandsDir: string): CanonicalCommandFile[];
+export declare function parseCommandContent(content: string): {
+    body: string;
+    frontmatter?: Record<string, unknown>;
+};
+export declare function getCommandProviderConfig(command: CanonicalCommandFile, provider: Provider): Record<string, unknown> | null;
+export declare function isCommandProviderEnabled(command: CanonicalCommandFile, provider: Provider): boolean;
+export declare function renderCommandForProvider(command: CanonicalCommandFile, provider: Provider): string | null;
+export declare function normalizeCommandArgumentsForProvider(body: string, provider: Provider): string;
+export declare function normalizeCommandArgumentsForCanonical(body: string, provider: Provider): string;
 export declare function stripCommandFileExtension(fileName: string): string;
 export declare function commandFileMatchesSelector(fileName: string, selector: string): boolean;
 export declare function normalizeCommandSelector(selector: string): string;