agentloom 0.1.5 → 0.1.7

package/dist/core/sources.js

@@ -56,55 +56,179 @@ export function prepareSource(options) {
         },
     };
 }
+export function discoverPluginSourceRoots(importRoot) {
+    const marketplacePath = path.join(importRoot, ".claude-plugin", "marketplace.json");
+    if (!fs.existsSync(marketplacePath) ||
+        !fs.statSync(marketplacePath).isFile()) {
+        return [];
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(marketplacePath, "utf8"));
+    }
+    catch {
+        return [];
+    }
+    const plugins = Array.isArray(parsed?.plugins)
+        ? parsed.plugins
+        : [];
+    const discoveredRoots = [];
+    for (const plugin of plugins) {
+        if (!plugin ||
+            typeof plugin !== "object" ||
+            Array.isArray(plugin) ||
+            typeof plugin.source !== "string") {
+            continue;
+        }
+        const source = plugin.source.trim();
+        if (!source)
+            continue;
+        const pluginRoot = path.resolve(importRoot, source);
+        if (!isPathWithinRoot(importRoot, pluginRoot)) {
+            continue;
+        }
+        if (!fs.existsSync(pluginRoot) || !fs.statSync(pluginRoot).isDirectory()) {
+            continue;
+        }
+        discoveredRoots.push(pluginRoot);
+    }
+    return dedupePaths(discoveredRoots);
+}
 export function discoverSourceAgentsDir(importRoot) {
-    const direct = path.join(importRoot, "agents");
-    if (fs.existsSync(direct) && fs.statSync(direct).isDirectory()) {
+    return discoverSourceAgentsDirs(importRoot)[0] ?? null;
+}
+export function discoverSourceAgentsDirs(importRoot) {
+    const direct = discoverSourceAgentsDirsForRoot(importRoot);
+    if (direct.length > 0) {
         return direct;
     }
-    const nested = path.join(importRoot, ".agents", "agents");
-    if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
-        return nested;
-    }
-    return null;
+    return dedupePaths(discoverPluginSourceRoots(importRoot).flatMap((pluginRoot) => discoverSourceAgentsDirsForRoot(pluginRoot)));
 }
 export function discoverSourceMcpPath(importRoot) {
-    const nested = path.join(importRoot, ".agents", "mcp.json");
-    if (fs.existsSync(nested))
-        return nested;
-    const direct = path.join(importRoot, "mcp.json");
-    if (fs.existsSync(direct))
+    return discoverSourceMcpPaths(importRoot)[0] ?? null;
+}
+export function discoverSourceMcpPaths(importRoot) {
+    const direct = discoverSourceMcpPathsForRoot(importRoot);
+    if (direct.length > 0) {
         return direct;
-    return null;
+    }
+    return dedupePaths(discoverPluginSourceRoots(importRoot).flatMap((pluginRoot) => discoverSourceMcpPathsForRoot(pluginRoot)));
 }
-export function discoverSourceCommandsDir(importRoot) {
+export function discoverSourceCommandsDirs(importRoot) {
+    const direct = discoverSourceCommandsDirsForRoot(importRoot);
+    if (direct.length > 0) {
+        return direct;
+    }
+    return dedupePaths(discoverPluginSourceRoots(importRoot).flatMap((pluginRoot) => discoverSourceCommandsDirsForRoot(pluginRoot)));
+}
+function discoverSourceCommandsDirsForRoot(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];
+    }
+    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 null;
+    return providerFallbacks;
+}
+export function discoverSourceCommandsDir(importRoot) {
+    return discoverSourceCommandsDirs(importRoot)[0] ?? null;
 }
 export function discoverSourceSkillsDir(importRoot) {
+    return discoverSourceSkillsDirs(importRoot)[0] ?? null;
+}
+export function discoverSourceSkillsDirs(importRoot) {
+    const direct = discoverSourceSkillsDirsForRoot(importRoot);
+    if (direct.length > 0) {
+        return direct;
+    }
+    return dedupePaths(discoverPluginSourceRoots(importRoot).flatMap((pluginRoot) => discoverSourceSkillsDirsForRoot(pluginRoot)));
+}
+export function discoverSourceRulesDir(importRoot) {
+    return discoverSourceRulesDirs(importRoot)[0] ?? null;
+}
+export function discoverSourceRulesDirs(importRoot) {
+    const direct = discoverSourceRulesDirsForRoot(importRoot);
+    if (direct.length > 0) {
+        return direct;
+    }
+    return dedupePaths(discoverPluginSourceRoots(importRoot).flatMap((pluginRoot) => discoverSourceRulesDirsForRoot(pluginRoot)));
+}
+function discoverSourceAgentsDirsForRoot(importRoot) {
+    const direct = path.join(importRoot, "agents");
+    if (fs.existsSync(direct) && fs.statSync(direct).isDirectory()) {
+        return [direct];
+    }
+    const nested = path.join(importRoot, ".agents", "agents");
+    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 [];
+}
+function discoverSourceMcpPathsForRoot(importRoot) {
+    const nested = path.join(importRoot, ".agents", "mcp.json");
+    if (fs.existsSync(nested) && fs.statSync(nested).isFile()) {
+        return [nested];
+    }
+    const direct = path.join(importRoot, "mcp.json");
+    if (fs.existsSync(direct) && fs.statSync(direct).isFile()) {
+        return [direct];
+    }
+    return [];
+}
+function discoverSourceSkillsDirsForRoot(importRoot) {
     const nested = path.join(importRoot, ".agents", "skills");
     if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
-        return nested;
+        return [nested];
     }
     const direct = path.join(importRoot, "skills");
     if (fs.existsSync(direct) && fs.statSync(direct).isDirectory()) {
-        return direct;
+        return [direct];
     }
     const rootSkill = path.join(importRoot, "SKILL.md");
     if (fs.existsSync(rootSkill) && fs.statSync(rootSkill).isFile()) {
-        return importRoot;
+        return [importRoot];
     }
-    return null;
+    return [];
+}
+function discoverSourceRulesDirsForRoot(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 [];
+}
+function dedupePaths(paths) {
+    return [...new Set(paths)];
+}
+function isPathWithinRoot(rootPath, targetPath) {
+    const relative = path.relative(rootPath, targetPath);
+    return (relative === "" ||
+        (!relative.startsWith("..") && !path.isAbsolute(relative)));
 }
 function resolveImportRoot(rootPath, subdir) {
     if (!subdir)

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({