agentloom 0.1.5 → 0.1.6

package/dist/core/provider-entity-validation.d.ts

@@ -0,0 +1,8 @@
+import type { Provider } from "../types.js";
+type ProviderEntity = "agent" | "command";
+export declare function isProviderEntityFileName(options: {
+    provider: Provider;
+    entity: ProviderEntity;
+    fileName: string;
+}): boolean;
+export {};

package/dist/core/provider-entity-validation.js

@@ -0,0 +1,34 @@
+import path from "node:path";
+const COPILOT_AGENT_FILE = /\.agent\.md$/i;
+const COPILOT_COMMAND_FILE = /\.prompt\.md$/i;
+const GENERIC_AGENT_FILE = /\.md$/i;
+const GENERIC_COMMAND_FILE = /(?:\.prompt)?\.(md|mdc)$/i;
+const GEMINI_COMMAND_FILE = /\.(toml|md|mdc)$/i;
+const EXCLUDED_ENTITY_STEMS = new Set(["readme"]);
+export function isProviderEntityFileName(options) {
+    const normalizedName = path.basename(options.fileName);
+    const stem = normalizeEntityStem(normalizedName);
+    if (!stem || EXCLUDED_ENTITY_STEMS.has(stem)) {
+        return false;
+    }
+    if (options.provider === "copilot") {
+        if (options.entity === "agent") {
+            return COPILOT_AGENT_FILE.test(normalizedName);
+        }
+        return COPILOT_COMMAND_FILE.test(normalizedName);
+    }
+    if (options.entity === "agent") {
+        return GENERIC_AGENT_FILE.test(normalizedName);
+    }
+    if (options.provider === "gemini") {
+        return GEMINI_COMMAND_FILE.test(normalizedName);
+    }
+    return GENERIC_COMMAND_FILE.test(normalizedName);
+}
+function normalizeEntityStem(fileName) {
+    return fileName
+        .toLowerCase()
+        .replace(/\.agent\.md$/i, "")
+        .replace(/\.prompt\.(md|mdc)$/i, "")
+        .replace(/\.(md|mdc|toml)$/i, "");
+}

package/dist/core/provider-paths.d.ts

@@ -1,7 +1,14 @@
 import type { Provider, ScopePaths } from "../types.js";
 export declare function getProviderAgentsDir(paths: ScopePaths, provider: Provider): string;
 export declare function getProviderCommandsDir(paths: ScopePaths, provider: Provider): string;
-export declare function getProviderSkillsPaths(paths: ScopePaths, providers: Provider[]): string[];
+export declare function getProviderSkillsPaths(paths: ScopePaths, providers: readonly Provider[]): string[];
+export declare function getCursorRulesDir(paths: ScopePaths): string;
+export declare function getAgentsInstructionPath(paths: ScopePaths): string;
+export declare function getClaudeInstructionPath(paths: ScopePaths): string;
+export declare function getGeminiInstructionPath(paths: ScopePaths): string;
+export declare function getCopilotInstructionPath(paths: ScopePaths): string;
+export declare function getOpenCodeInstructionPath(paths: ScopePaths): string;
+export declare function getRuleInstructionPaths(paths: ScopePaths, providers: readonly Provider[]): string[];
 export declare function getCursorMcpPath(paths: ScopePaths): string;
 export declare function getClaudeMcpPath(paths: ScopePaths): string;
 export declare function getClaudeSettingsPath(paths: ScopePaths): string;

package/dist/core/provider-paths.js

@@ -25,7 +25,7 @@ export function getProviderAgentsDir(paths, provider) {
         case "copilot":
             return paths.scope === "local"
                 ? path.join(workspaceRoot, ".github", "agents")
-                : path.join(home, ".vscode", "chatmodes");
+                : path.join(home, ".copilot", "agents");
         case "pi":
             return paths.scope === "local"
                 ? path.join(workspaceRoot, ".pi", "agents")
@@ -59,7 +59,7 @@ export function getProviderCommandsDir(paths, provider) {
         case "copilot":
             return paths.scope === "local"
                 ? path.join(workspaceRoot, ".github", "prompts")
-                : path.join(home, ".github", "prompts");
+                : path.join(home, ".copilot", "prompts");
         case "pi":
             return paths.scope === "local"
                 ? path.join(workspaceRoot, ".pi", "prompts")
@@ -70,12 +70,16 @@ export function getProviderCommandsDir(paths, provider) {
 }
 export function getProviderSkillsPaths(paths, providers) {
     const targets = new Set();
-    const hasClaudeStyleProvider = providers.includes("claude") || providers.includes("copilot");
-    if (hasClaudeStyleProvider) {
+    if (providers.includes("claude")) {
         targets.add(paths.scope === "local"
             ? path.join(paths.workspaceRoot, ".claude", "skills")
             : path.join(paths.homeDir, ".claude", "skills"));
     }
+    if (providers.includes("copilot")) {
+        targets.add(paths.scope === "local"
+            ? path.join(paths.workspaceRoot, ".github", "skills")
+            : path.join(paths.homeDir, ".copilot", "skills"));
+    }
     if (providers.includes("cursor")) {
         targets.add(paths.scope === "local"
             ? path.join(paths.workspaceRoot, ".cursor", "skills")
@@ -88,6 +92,66 @@ export function getProviderSkillsPaths(paths, providers) {
     }
     return [...targets];
 }
+export function getCursorRulesDir(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".cursor", "rules")
+        : path.join(paths.homeDir, ".cursor", "rules");
+}
+export function getAgentsInstructionPath(paths) {
+    return path.join(paths.workspaceRoot, "AGENTS.md");
+}
+export function getClaudeInstructionPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, "CLAUDE.md")
+        : path.join(paths.homeDir, ".claude", "CLAUDE.md");
+}
+export function getGeminiInstructionPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, "GEMINI.md")
+        : path.join(paths.homeDir, ".gemini", "GEMINI.md");
+}
+export function getCopilotInstructionPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, ".github", "copilot-instructions.md")
+        : path.join(paths.homeDir, ".copilot", "copilot-instructions.md");
+}
+export function getOpenCodeInstructionPath(paths) {
+    return paths.scope === "local"
+        ? path.join(paths.workspaceRoot, "AGENTS.md")
+        : path.join(paths.homeDir, ".config", "opencode", "AGENTS.md");
+}
+export function getRuleInstructionPaths(paths, providers) {
+    const targets = new Set();
+    if (paths.scope === "local") {
+        targets.add(getAgentsInstructionPath(paths));
+    }
+    for (const provider of providers) {
+        if (provider === "claude") {
+            targets.add(getClaudeInstructionPath(paths));
+            continue;
+        }
+        if (provider === "gemini") {
+            targets.add(getGeminiInstructionPath(paths));
+            continue;
+        }
+        if (provider === "copilot") {
+            targets.add(getCopilotInstructionPath(paths));
+            continue;
+        }
+        if (provider === "opencode") {
+            targets.add(getOpenCodeInstructionPath(paths));
+            continue;
+        }
+        if (provider === "codex" && paths.scope === "local") {
+            targets.add(getAgentsInstructionPath(paths));
+            continue;
+        }
+        if (provider === "pi" && paths.scope === "local") {
+            targets.add(getAgentsInstructionPath(paths));
+        }
+    }
+    return [...targets];
+}
 export function getCursorMcpPath(paths) {
     return paths.scope === "local"
         ? path.join(paths.workspaceRoot, ".cursor", "mcp.json")
@@ -101,7 +165,7 @@ export function getClaudeMcpPath(paths) {
 export function getClaudeSettingsPath(paths) {
     return paths.scope === "local"
         ? path.join(paths.workspaceRoot, ".claude", "settings.json")
-        : path.join(paths.homeDir, ".claude.json");
+        : path.join(paths.homeDir, ".claude", "settings.json");
 }
 export function getOpenCodeConfigPath(paths) {
     return paths.scope === "local"

package/dist/core/router.js

@@ -7,7 +7,13 @@ const AGGREGATE_VERBS = new Set([
     "delete",
     "init",
 ]);
-const ENTITY_NOUNS = new Set(["agent", "command", "mcp", "skill"]);
+const ENTITY_NOUNS = new Set([
+    "agent",
+    "command",
+    "mcp",
+    "rule",
+    "skill",
+]);
 const ENTITY_VERBS = new Set([
     "add",
     "list",

package/dist/core/rules.d.ts

@@ -0,0 +1,34 @@
+export interface CanonicalRuleFile {
+    id: string;
+    name: string;
+    fileName: string;
+    sourcePath: string;
+    content: string;
+    body: string;
+    frontmatter: Record<string, unknown> & {
+        name: string;
+    };
+}
+export interface ManagedRuleBlock {
+    id: string;
+    name: string;
+    body: string;
+}
+export declare function parseRulesDir(rulesDir: string): CanonicalRuleFile[];
+export declare function parseRuleMarkdown(content: string, sourcePath?: string): {
+    name: string;
+    body: string;
+    frontmatter: Record<string, unknown> & {
+        name: string;
+    };
+};
+export declare function normalizeRuleSelector(selector: string): string;
+export declare function resolveRuleSelections(rules: CanonicalRuleFile[], selectors: string[]): {
+    selected: CanonicalRuleFile[];
+    unmatched: string[];
+};
+export declare function renderRuleForCursor(rule: CanonicalRuleFile): string;
+export declare function renderManagedRuleBlock(rule: CanonicalRuleFile): string;
+export declare function parseManagedRuleBlocks(content: string): ManagedRuleBlock[];
+export declare function upsertManagedRuleBlocks(existingContent: string, rules: CanonicalRuleFile[]): string;
+export declare function stripRuleFileExtension(fileName: string): string;

package/dist/core/rules.js

@@ -0,0 +1,149 @@
+import fs from "node:fs";
+import path from "node:path";
+import matter from "gray-matter";
+import YAML from "yaml";
+import { listMarkdownFiles, slugify } from "./fs.js";
+const MANAGED_BLOCK_PATTERN = /<!--\s*agentloom:([a-z0-9._-]+):start\s*-->[\s\S]*?<!--\s*agentloom:\1:end\s*-->\s*/gi;
+const MANAGED_BLOCK_CAPTURE_PATTERN = /<!--\s*agentloom:([a-z0-9._-]+):start\s*-->\s*([\s\S]*?)\s*<!--\s*agentloom:\1:end\s*-->/gi;
+export function parseRulesDir(rulesDir) {
+    if (!fs.existsSync(rulesDir))
+        return [];
+    return listMarkdownFiles(rulesDir)
+        .sort((a, b) => a.localeCompare(b))
+        .map((sourcePath) => {
+        const content = fs.readFileSync(sourcePath, "utf8");
+        const fileName = path.basename(sourcePath);
+        const parsed = parseRuleMarkdown(content, sourcePath);
+        return {
+            id: stripRuleFileExtension(fileName),
+            name: parsed.name,
+            fileName,
+            sourcePath,
+            content,
+            body: parsed.body,
+            frontmatter: parsed.frontmatter,
+        };
+    });
+}
+export function parseRuleMarkdown(content, sourcePath = "<rule>") {
+    const parsed = matter(content);
+    if (!parsed.data ||
+        typeof parsed.data !== "object" ||
+        Array.isArray(parsed.data)) {
+        throw new Error(`Rule "${sourcePath}" must include YAML frontmatter with required "name".`);
+    }
+    const frontmatter = parsed.data;
+    if (typeof frontmatter.name !== "string" || frontmatter.name.trim() === "") {
+        throw new Error(`Rule "${sourcePath}" is missing required frontmatter.name.`);
+    }
+    return {
+        name: frontmatter.name.trim(),
+        body: parsed.content.trimStart(),
+        frontmatter: {
+            ...frontmatter,
+            name: frontmatter.name.trim(),
+        },
+    };
+}
+export function normalizeRuleSelector(selector) {
+    const trimmed = selector.trim().replace(/^\/+/, "");
+    const withoutExt = stripRuleFileExtension(trimmed);
+    const normalized = slugify(withoutExt);
+    return normalized || withoutExt.toLowerCase();
+}
+export function resolveRuleSelections(rules, selectors) {
+    const selectedById = new Map();
+    const unmatched = [];
+    for (const selector of selectors) {
+        const normalizedSelector = normalizeRuleSelector(selector);
+        if (!normalizedSelector) {
+            continue;
+        }
+        const matches = rules.filter((rule) => {
+            const exactCandidates = new Set([
+                rule.id.toLowerCase(),
+                stripRuleFileExtension(rule.fileName).toLowerCase(),
+            ]);
+            const slugCandidates = new Set([
+                normalizeRuleSelector(rule.id),
+                normalizeRuleSelector(stripRuleFileExtension(rule.fileName)),
+                normalizeRuleSelector(rule.name),
+            ]);
+            return (exactCandidates.has(normalizedSelector) ||
+                slugCandidates.has(normalizedSelector));
+        });
+        if (matches.length === 0) {
+            unmatched.push(selector);
+            continue;
+        }
+        for (const match of matches) {
+            selectedById.set(match.id, match);
+        }
+    }
+    return {
+        selected: [...selectedById.values()],
+        unmatched,
+    };
+}
+export function renderRuleForCursor(rule) {
+    const fm = YAML.stringify(rule.frontmatter, { lineWidth: 0 }).trimEnd();
+    const body = rule.body.trimStart();
+    return `---\n${fm}\n---\n\n${body}${body.endsWith("\n") ? "" : "\n"}`;
+}
+export function renderManagedRuleBlock(rule) {
+    const body = rule.body.trim();
+    const heading = `## ${rule.name}`;
+    const content = body ? `${heading}\n\n${body}` : heading;
+    return `<!-- agentloom:${rule.id}:start -->\n${content}\n<!-- agentloom:${rule.id}:end -->`;
+}
+export function parseManagedRuleBlocks(content) {
+    const blocks = [];
+    content.replace(MANAGED_BLOCK_CAPTURE_PATTERN, (_match, rawId, rawInner) => {
+        const id = String(rawId).trim();
+        const inner = String(rawInner).trim();
+        const headingMatch = inner.match(/^##\s+(.+?)(?:\r?\n([\s\S]*))?$/);
+        const name = headingMatch?.[1]?.trim() || id;
+        const body = (headingMatch?.[2] ?? inner).replace(/^\r?\n/, "").trim();
+        blocks.push({
+            id,
+            name,
+            body: headingMatch ? body : inner,
+        });
+        return "";
+    });
+    return blocks;
+}
+export function upsertManagedRuleBlocks(existingContent, rules) {
+    const byId = new Map(rules.map((rule) => [rule.id, rule]));
+    const seen = new Set();
+    let nextContent = existingContent.replace(MANAGED_BLOCK_PATTERN, (match, id) => {
+        const normalizedId = String(id).trim();
+        const rule = byId.get(normalizedId);
+        if (!rule) {
+            return "";
+        }
+        if (seen.has(normalizedId)) {
+            return "";
+        }
+        seen.add(normalizedId);
+        const suffix = /\n$/.test(match) ? "\n" : "";
+        return `${renderManagedRuleBlock(rule)}${suffix}`;
+    });
+    const missing = rules
+        .filter((rule) => !seen.has(rule.id))
+        .map((rule) => renderManagedRuleBlock(rule));
+    if (missing.length === 0) {
+        return nextContent;
+    }
+    if (nextContent.trim().length === 0) {
+        return `${missing.join("\n\n")}\n`;
+    }
+    const trailingNewline = nextContent.endsWith("\n") ? "" : "\n";
+    return `${nextContent}${trailingNewline}\n${missing.join("\n\n")}\n`;
+}
+export function stripRuleFileExtension(fileName) {
+    const ext = path.extname(fileName);
+    if (!ext)
+        return fileName;
+    return fileName.slice(0, -ext.length);
+}

package/dist/core/scope.js

@@ -15,6 +15,7 @@ export function buildScopePaths(cwd, scope, homeDir = os.homedir()) {
         agentsRoot,
         agentsDir: path.join(agentsRoot, "agents"),
         commandsDir: path.join(agentsRoot, "commands"),
+        rulesDir: path.join(agentsRoot, "rules"),
         skillsDir: path.join(agentsRoot, "skills"),
         mcpPath: path.join(agentsRoot, "mcp.json"),
         lockPath: path.join(agentsRoot, "agents.lock.json"),

package/dist/core/skills.d.ts

@@ -21,3 +21,4 @@ export declare function applySkillProviderSideEffects(options: {
     dryRun?: boolean;
     warn?: (message: string) => void;
 }): void;
+export declare function getLegacyCopilotSkillDirs(paths: ScopePaths): string[];

package/dist/core/skills.js

@@ -125,13 +125,21 @@ export function skillContentMatchesTarget(skill, targetDir) {
 }
 export function applySkillProviderSideEffects(options) {
     const pathsToSymlink = getProviderSkillsPaths(options.paths, options.providers);
-    if (pathsToSymlink.length === 0)
+    if (options.providers.includes("copilot")) {
+        const copilotTargets = getProviderSkillsPaths(options.paths, ["copilot"]);
+        const hasCurrentCopilotTarget = copilotTargets.some((targetPath) => fs.existsSync(targetPath));
+        if (!hasCurrentCopilotTarget) {
+            pathsToSymlink.push(...getLegacyCopilotSkillDirs(options.paths));
+        }
+    }
+    const uniquePathsToSymlink = [...new Set(pathsToSymlink)];
+    if (uniquePathsToSymlink.length === 0)
         return;
     const canonicalSkillsDir = options.paths.skillsDir;
     if (!options.dryRun) {
         ensureDir(canonicalSkillsDir);
     }
-    for (const targetSkillsDir of pathsToSymlink) {
+    for (const targetSkillsDir of uniquePathsToSymlink) {
         enforceProviderSkillsSymlink({
             targetSkillsDir,
             canonicalSkillsDir,
@@ -140,6 +148,17 @@ export function applySkillProviderSideEffects(options) {
         });
     }
 }
+export function getLegacyCopilotSkillDirs(paths) {
+    const legacyDirs = [
+        paths.scope === "local"
+            ? path.join(paths.workspaceRoot, ".claude", "skills")
+            : path.join(paths.homeDir, ".claude", "skills"),
+    ];
+    if (paths.scope === "global") {
+        legacyDirs.push(path.join(paths.homeDir, ".github", "skills"));
+    }
+    return legacyDirs;
+}
 function enforceProviderSkillsSymlink(options) {
     const resolvedCanonical = realPathOrResolved(options.canonicalSkillsDir);
     const targetDir = options.targetSkillsDir;

package/dist/core/sources.d.ts

@@ -18,5 +18,7 @@ export declare function prepareSource(options: {
 }): PreparedSource;
 export declare function discoverSourceAgentsDir(importRoot: string): string | null;
 export declare function discoverSourceMcpPath(importRoot: string): string | null;
+export declare function discoverSourceCommandsDirs(importRoot: string): string[];
 export declare function discoverSourceCommandsDir(importRoot: string): string | null;
 export declare function discoverSourceSkillsDir(importRoot: string): string | null;
+export declare function discoverSourceRulesDir(importRoot: string): string | null;

package/dist/core/sources.js

@@ -65,6 +65,10 @@ export function discoverSourceAgentsDir(importRoot) {
     if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
         return nested;
     }
+    const githubAgents = path.join(importRoot, ".github", "agents");
+    if (fs.existsSync(githubAgents) && fs.statSync(githubAgents).isDirectory()) {
+        return githubAgents;
+    }
     return null;
 }
 export function discoverSourceMcpPath(importRoot) {
@@ -76,20 +80,34 @@ export function discoverSourceMcpPath(importRoot) {
         return direct;
     return null;
 }
-export function discoverSourceCommandsDir(importRoot) {
+export function discoverSourceCommandsDirs(importRoot) {
     const nested = path.join(importRoot, ".agents", "commands");
     if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
-        return nested;
+        return [nested];
     }
     const direct = path.join(importRoot, "commands");
     if (fs.existsSync(direct) && fs.statSync(direct).isDirectory()) {
-        return direct;
+        return [direct];
     }
     const prompts = path.join(importRoot, "prompts");
     if (fs.existsSync(prompts) && fs.statSync(prompts).isDirectory()) {
-        return prompts;
+        return [prompts];
     }
-    return null;
+    const providerFallbacks = [];
+    const githubPrompts = path.join(importRoot, ".github", "prompts");
+    if (fs.existsSync(githubPrompts) &&
+        fs.statSync(githubPrompts).isDirectory()) {
+        providerFallbacks.push(githubPrompts);
+    }
+    const geminiCommands = path.join(importRoot, ".gemini", "commands");
+    if (fs.existsSync(geminiCommands) &&
+        fs.statSync(geminiCommands).isDirectory()) {
+        providerFallbacks.push(geminiCommands);
+    }
+    return providerFallbacks;
+}
+export function discoverSourceCommandsDir(importRoot) {
+    return discoverSourceCommandsDirs(importRoot)[0] ?? null;
 }
 export function discoverSourceSkillsDir(importRoot) {
     const nested = path.join(importRoot, ".agents", "skills");
@@ -106,6 +124,17 @@ export function discoverSourceSkillsDir(importRoot) {
     }
     return null;
 }
+export function discoverSourceRulesDir(importRoot) {
+    const nested = path.join(importRoot, ".agents", "rules");
+    if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
+        return nested;
+    }
+    const direct = path.join(importRoot, "rules");
+    if (fs.existsSync(direct) && fs.statSync(direct).isDirectory()) {
+        return direct;
+    }
+    return null;
+}
 function resolveImportRoot(rootPath, subdir) {
     if (!subdir)
         return rootPath;

package/dist/core/telemetry.d.ts

@@ -4,7 +4,7 @@ export type TelemetrySource = {
     repo: string;
 };
 export type TelemetryItem = {
-    entityType: "agent" | "skill" | "command" | "mcp";
+    entityType: "agent" | "skill" | "command" | "mcp" | "rule";
     name: string;
     filePath: string;
 };

package/dist/core/telemetry.js

@@ -47,6 +47,7 @@ export function parseGitHubSource(input) {
 }
 export function buildTelemetryItems(summary) {
     const items = [];
+    const importedRules = summary.importedRules ?? [];
     for (const filePath of summary.importedAgents) {
         const name = path.basename(filePath, path.extname(filePath));
         items.push({ entityType: "agent", name, filePath });
@@ -58,6 +59,21 @@ export function buildTelemetryItems(summary) {
     for (const serverName of summary.importedMcpServers) {
         items.push({ entityType: "mcp", name: serverName, filePath: "mcp.json" });
     }
+    if (summary.telemetryRules && summary.telemetryRules.length > 0) {
+        for (const rule of summary.telemetryRules) {
+            items.push({
+                entityType: "rule",
+                name: rule.name,
+                filePath: rule.filePath.replace(/^\/+/, ""),
+            });
+        }
+    }
+    else {
+        for (const filePath of importedRules) {
+            const name = path.basename(filePath, path.extname(filePath));
+            items.push({ entityType: "rule", name, filePath });
+        }
+    }
     if (summary.telemetrySkills && summary.telemetrySkills.length > 0) {
         for (const skill of summary.telemetrySkills) {
             items.push({