agentloom 0.1.5 → 0.1.7

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,20 @@ 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_NOUN_ALIASES = {
+    agents: "agent",
+    commands: "command",
+    mcps: "mcp",
+    rules: "rule",
+    skills: "skill",
+};
 const ENTITY_VERBS = new Set([
     "add",
     "list",
@@ -18,9 +31,10 @@ const ENTITY_VERBS = new Set([
 ]);
 const MCP_SERVER_VERBS = new Set(["add", "list", "delete"]);
 export function parseCommandRoute(argv) {
-    const root = argv[0]?.trim().toLowerCase();
-    if (!root)
+    const rawRoot = argv[0]?.trim().toLowerCase();
+    if (!rawRoot)
         return null;
+    const root = ENTITY_NOUN_ALIASES[rawRoot] ?? rawRoot;
     if (AGGREGATE_VERBS.has(root)) {
         return {
             mode: "aggregate",

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

@@ -1,6 +1,8 @@
 import type { Provider, ScopePaths } from "../types.js";
 export interface CanonicalSkill {
     name: string;
+    aliases: string[];
+    sourceDirName: string;
     sourcePath: string;
     skillPath: string;
     layout: "nested" | "root";
@@ -8,6 +10,7 @@ export interface CanonicalSkill {
 export declare const ROOT_SKILL_ARTIFACT_DIRS: readonly ["references", "assets", "scripts", "templates", "examples"];
 export declare function parseSkillsDir(skillsDir: string): CanonicalSkill[];
 export declare function normalizeSkillSelector(value: string): string;
+export declare function resolveSkillSelector(skills: CanonicalSkill[], selector: string): CanonicalSkill | null;
 export declare function resolveSkillSelections(skills: CanonicalSkill[], selectors: string[]): {
     selected: CanonicalSkill[];
     unmatched: string[];
@@ -21,3 +24,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

@@ -22,8 +22,12 @@ export function parseSkillsDir(skillsDir) {
         const skillFile = path.join(skillDir, "SKILL.md");
         if (!fs.existsSync(skillFile))
             continue;
+        const raw = fs.readFileSync(skillFile, "utf8");
+        const canonicalName = extractSkillName(raw) || entry.name;
         skills.push({
-            name: entry.name,
+            name: canonicalName,
+            aliases: buildSkillAliases(canonicalName, entry.name),
+            sourceDirName: entry.name,
             sourcePath: skillDir,
             skillPath: skillFile,
             layout: "nested",
@@ -37,9 +41,12 @@ export function parseSkillsDir(skillsDir) {
         return [];
     }
     const raw = fs.readFileSync(rootSkillFile, "utf8");
+    const canonicalName = extractSkillName(raw) || path.basename(skillsDir);
     return [
         {
-            name: extractSkillName(raw) || path.basename(skillsDir),
+            name: canonicalName,
+            aliases: buildSkillAliases(canonicalName, path.basename(skillsDir)),
+            sourceDirName: path.basename(skillsDir),
             sourcePath: skillsDir,
             skillPath: rootSkillFile,
             layout: "root",
@@ -61,6 +68,16 @@ function extractSkillName(raw) {
 export function normalizeSkillSelector(value) {
     return slugify(value.trim().replace(/\/+$/, "")).toLowerCase();
 }
+export function resolveSkillSelector(skills, selector) {
+    const normalizedSelector = normalizeSkillSelector(selector);
+    if (!normalizedSelector)
+        return null;
+    const canonicalMatch = skills.find((skill) => normalizeSkillSelector(skill.name) === normalizedSelector) ?? null;
+    if (canonicalMatch) {
+        return canonicalMatch;
+    }
+    return (skills.find((skill) => normalizeSkillSelector(skill.sourceDirName) === normalizedSelector) ?? null);
+}
 export function resolveSkillSelections(skills, selectors) {
     const normalizedSelectors = selectors
         .map((item) => item.trim())
@@ -70,14 +87,12 @@ export function resolveSkillSelections(skills, selectors) {
     const selectedMap = new Map();
     const unmatched = [];
     for (const selector of normalizedSelectors) {
-        const matches = skills.filter((skill) => normalizeSkillSelector(skill.name) === selector);
-        if (matches.length === 0) {
+        const match = resolveSkillSelector(skills, selector);
+        if (!match) {
             unmatched.push(selector);
             continue;
         }
-        for (const match of matches) {
-            selectedMap.set(match.name, match);
-        }
+        selectedMap.set(match.name, match);
     }
     return {
         selected: [...selectedMap.values()],
@@ -125,13 +140,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 +163,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;
@@ -176,9 +210,7 @@ function enforceProviderSkillsSymlink(options) {
 function migrateProviderSkillsIntoCanonical(options) {
     const providerSkills = parseSkillsDir(options.providerSkillsDir);
     for (const skill of providerSkills) {
-        const targetSkillDirName = skill.layout === "nested"
-            ? path.basename(skill.sourcePath)
-            : slugify(skill.name) || "skill";
+        const targetSkillDirName = slugify(skill.name) || "skill";
         const targetSkillDir = path.join(options.canonicalSkillsDir, targetSkillDirName);
         if (fs.existsSync(targetSkillDir)) {
             const sameContent = skill.layout === "nested"
@@ -199,6 +231,9 @@ function migrateProviderSkillsIntoCanonical(options) {
         copyRootSkillArtifacts(skill.sourcePath, targetSkillDir);
     }
 }
+function buildSkillAliases(name, sourceDirName) {
+    return [...new Set([name, sourceDirName].filter(Boolean))];
+}
 function moveDirectory(sourceDir, targetDir) {
     ensureDir(path.dirname(targetDir));
     try {

package/dist/core/sources.d.ts

@@ -16,7 +16,14 @@ export declare function prepareSource(options: {
     ref?: string;
     subdir?: string;
 }): PreparedSource;
+export declare function discoverPluginSourceRoots(importRoot: string): string[];
 export declare function discoverSourceAgentsDir(importRoot: string): string | null;
+export declare function discoverSourceAgentsDirs(importRoot: string): string[];
 export declare function discoverSourceMcpPath(importRoot: string): string | null;
+export declare function discoverSourceMcpPaths(importRoot: string): string[];
+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 discoverSourceSkillsDirs(importRoot: string): string[];
+export declare function discoverSourceRulesDir(importRoot: string): string | null;
+export declare function discoverSourceRulesDirs(importRoot: string): string[];