loadouts 0.2.0 → 0.2.2

package/dist/core/import-discovery.js

@@ -3,34 +3,14 @@
  * that can be imported into loadout.
  */
 import * as fs from "node:fs";
+import * as os from "node:os";
 import * as path from "node:path";
-import { fileExists, isDirectory, isSymlink, listFiles, listFilesWithExtension } from "../lib/fs.js";
-const TOOL_LOCATIONS = {
-    "claude-code": {
-        rules: { dir: ".claude/rules", ext: ".md" },
-        skills: { dir: ".claude/skills" },
-    },
-    cursor: {
-        rules: { dir: ".cursor/rules", ext: ".mdc" },
-        skills: { dir: ".cursor/skills" },
-    },
-    opencode: {
-        rules: { dir: ".opencode/rules", ext: ".md" },
-        skills: { dir: ".opencode/skills" },
-    },
-    codex: {
-        // codex doesn't support rules
-        skills: { dir: ".agents/skills" },
-    },
-    pi: {
-        // pi doesn't have native rules support
-        skills: { dir: ".pi/skills" },
-    },
-};
+import { fileExists, isDirectory, isSymlink, listFiles, walkDir } from "../lib/fs.js";
+import { registry } from "./registry.js";
 // Instruction file locations to check (in priority order)
 const INSTRUCTION_FILES = ["AGENTS.md", "CLAUDE.md"];
 // ---------------------------------------------------------------------------
-// Discovery functions
+// Filesystem helpers
 // ---------------------------------------------------------------------------
 /**
  * Get file/directory size.
@@ -53,86 +33,228 @@ function getSize(filePath) {
 function getMtime(filePath) {
     return fs.statSync(filePath).mtime;
 }
+function readArtifactMetadata(filePath) {
+    try {
+        return {
+            size: getSize(filePath),
+            mtime: getMtime(filePath),
+        };
+    }
+    catch {
+        return null;
+    }
+}
 /**
- * Discover rules in a tool directory.
+ * Convert Windows path separators to POSIX-style separators.
  */
-function discoverRules(projectRoot, tool, locations) {
-    if (!locations.rules)
-        return [];
-    const rulesDir = path.join(projectRoot, locations.rules.dir);
-    if (!isDirectory(rulesDir))
-        return [];
+function toPosix(filePath) {
+    return filePath.split(path.sep).join("/");
+}
+/**
+ * Escape string for safe regex inclusion.
+ */
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Select the path template for the requested scope.
+ */
+function getScopeTemplate(mappingPath, scope) {
+    return typeof mappingPath === "string" ? mappingPath : mappingPath[scope];
+}
+/**
+ * Resolve a tool base path to absolute for the current scope.
+ */
+function resolveAbsoluteBasePath(scanRoot, basePath) {
+    return path.isAbsolute(basePath) ? basePath : path.join(scanRoot, basePath);
+}
+/**
+ * Format a path for display relative to scan root when possible.
+ */
+function toDisplayPath(scanRoot, absolutePath) {
+    const rel = path.relative(scanRoot, absolutePath);
+    if (!rel.startsWith("..") && !path.isAbsolute(rel)) {
+        return toPosix(rel);
+    }
+    const home = os.homedir();
+    if (absolutePath === home)
+        return "~";
+    if (absolutePath.startsWith(`${home}${path.sep}`)) {
+        return `~/${toPosix(path.relative(home, absolutePath))}`;
+    }
+    return toPosix(absolutePath);
+}
+function isPathWithin(parentPath, childPath) {
+    const rel = path.relative(parentPath, childPath);
+    return rel === "" || (!!rel && !rel.startsWith("..") && !path.isAbsolute(rel));
+}
+function matchesSourcePath(artifact, sourcePath) {
+    if (artifact.kind === "skill" && isPathWithin(artifact.sourcePath, sourcePath)) {
+        return true;
+    }
+    return isPathWithin(sourcePath, artifact.sourcePath) || artifact.sourcePath === sourcePath;
+}
+function sourceAllowsKind(kindId, kinds) {
+    return !kinds || kinds.length === 0 || kinds.includes(kindId);
+}
+function buildSourceArtifact(scanRoot, kind, sourcePath, destPath, name) {
+    const metadata = readArtifactMetadata(sourcePath);
+    if (!metadata)
+        return null;
+    return {
+        kind,
+        name,
+        sourcePath,
+        displayPath: toDisplayPath(scanRoot, sourcePath),
+        tool: "source",
+        size: metadata.size,
+        mtime: metadata.mtime,
+        destPath,
+    };
+}
+function buildRuleSourceArtifact(scanRoot, sourcePath) {
+    const ext = path.extname(sourcePath).toLowerCase();
+    if (ext !== ".md" && ext !== ".mdc")
+        return null;
+    const stem = path.basename(sourcePath, ext);
+    if (!stem || stem === "AGENTS" || stem === "CLAUDE")
+        return null;
+    return buildSourceArtifact(scanRoot, "rule", sourcePath, `rules/${stem}.md`, stem);
+}
+function buildInstructionSourceArtifact(scanRoot, sourcePath) {
+    const basename = path.basename(sourcePath);
+    if (basename !== "AGENTS.md" && basename !== "CLAUDE.md" && !/^AGENTS\.[^.]+\.md$/.test(basename)) {
+        return null;
+    }
+    return buildSourceArtifact(scanRoot, "instruction", sourcePath, "instructions/AGENTS.base.md", "AGENTS.md");
+}
+function buildSkillSourceArtifact(scanRoot, skillDir) {
+    const skillMdPath = path.join(skillDir, "SKILL.md");
+    if (!fileExists(skillMdPath))
+        return null;
+    const name = path.basename(skillDir);
+    return buildSourceArtifact(scanRoot, "skill", skillDir, `skills/${name}`, name);
+}
+function discoverDirectSourceArtifacts(scanRoot, sourcePath, kinds) {
     const artifacts = [];
-    const files = listFilesWithExtension(rulesDir, locations.rules.ext);
-    for (const file of files) {
-        const sourcePath = path.join(rulesDir, file);
-        const name = file.replace(/\.(md|mdc)$/, "");
-        artifacts.push({
-            kind: "rule",
-            name,
-            sourcePath,
-            displayPath: path.join(locations.rules.dir, file),
-            tool,
-            size: getSize(sourcePath),
-            mtime: getMtime(sourcePath),
-            destPath: `rules/${name}.md`,
-        });
+    if (!fileExists(sourcePath))
+        return artifacts;
+    if (!isDirectory(sourcePath)) {
+        if (sourceAllowsKind("instruction", kinds)) {
+            const instruction = buildInstructionSourceArtifact(scanRoot, sourcePath);
+            if (instruction)
+                artifacts.push(instruction);
+        }
+        if (sourceAllowsKind("skill", kinds) && path.basename(sourcePath) === "SKILL.md") {
+            const skill = buildSkillSourceArtifact(scanRoot, path.dirname(sourcePath));
+            if (skill)
+                artifacts.push(skill);
+        }
+        if (sourceAllowsKind("rule", kinds)) {
+            const rule = buildRuleSourceArtifact(scanRoot, sourcePath);
+            if (rule)
+                artifacts.push(rule);
+        }
+        return artifacts;
+    }
+    if (sourceAllowsKind("skill", kinds)) {
+        const directSkill = buildSkillSourceArtifact(scanRoot, sourcePath);
+        if (directSkill)
+            artifacts.push(directSkill);
+    }
+    const basename = path.basename(sourcePath);
+    const rulesRoot = basename === "rules" ? sourcePath : path.join(sourcePath, "rules");
+    if (sourceAllowsKind("rule", kinds) && isDirectory(rulesRoot)) {
+        for (const rel of walkDir(rulesRoot)) {
+            const rule = buildRuleSourceArtifact(scanRoot, path.join(rulesRoot, rel));
+            if (rule)
+                artifacts.push(rule);
+        }
+    }
+    const skillsRoot = basename === "skills" ? sourcePath : path.join(sourcePath, "skills");
+    if (sourceAllowsKind("skill", kinds) && isDirectory(skillsRoot)) {
+        for (const entry of listFiles(skillsRoot)) {
+            const skillDir = path.join(skillsRoot, entry);
+            if (!isDirectory(skillDir))
+                continue;
+            const skill = buildSkillSourceArtifact(scanRoot, skillDir);
+            if (skill)
+                artifacts.push(skill);
+        }
+    }
+    const instructionsRoot = basename === "instructions" ? sourcePath : path.join(sourcePath, "instructions");
+    if (sourceAllowsKind("instruction", kinds) && isDirectory(instructionsRoot)) {
+        for (const rel of walkDir(instructionsRoot)) {
+            const instruction = buildInstructionSourceArtifact(scanRoot, path.join(instructionsRoot, rel));
+            if (instruction)
+                artifacts.push(instruction);
+        }
     }
     return artifacts;
 }
+function dedupeArtifacts(artifacts) {
+    const seen = new Set();
+    const deduped = [];
+    for (const artifact of artifacts) {
+        const key = `${artifact.kind}:${artifact.sourcePath}:${artifact.destPath}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        deduped.push(artifact);
+    }
+    return deduped;
+}
 /**
- * Discover skills in a tool directory.
- * Skips symlinked directories that point to other tool directories
- * to avoid duplicate detection.
+ * Build a regex matcher for a concrete template path.
+ * Supported tokens: {base} {home} {stem} {ext} {name} {relative} {kind}
  */
-function discoverSkills(projectRoot, tool, locations) {
-    if (!locations.skills)
-        return [];
-    const skillsDir = path.join(projectRoot, locations.skills.dir);
-    if (!isDirectory(skillsDir))
-        return [];
-    // Skip if this skills dir is a symlink pointing to another tool's directory
-    // (e.g., .cursor/skills -> ../.claude/skills)
-    if (isSymlink(skillsDir)) {
-        try {
-            const target = fs.realpathSync(skillsDir);
-            // Check if target is inside another tool's directory
-            for (const [otherTool, otherLoc] of Object.entries(TOOL_LOCATIONS)) {
-                if (otherTool === tool || !otherLoc.skills)
-                    continue;
-                const otherSkillsDir = path.join(projectRoot, otherLoc.skills.dir);
-                if (target.startsWith(fs.realpathSync(path.dirname(otherSkillsDir)))) {
-                    // This is a symlink to another tool's skills - skip to avoid duplicates
-                    return [];
-                }
+function matchTemplatePath(templatePath, actualPath) {
+    const captures = {};
+    const tokens = [];
+    let pattern = "";
+    for (let i = 0; i < templatePath.length; i += 1) {
+        const ch = templatePath[i];
+        if (ch === "{") {
+            const end = templatePath.indexOf("}", i + 1);
+            if (end === -1) {
+                pattern += escapeRegex(ch);
+                continue;
             }
+            const token = templatePath.slice(i + 1, end);
+            tokens.push(token);
+            switch (token) {
+                case "stem":
+                case "name":
+                case "kind":
+                    pattern += "([^/]+)";
+                    break;
+                case "ext":
+                    pattern += "([^/]*)";
+                    break;
+                case "relative":
+                    pattern += "(.+)";
+                    break;
+                case "base":
+                case "home":
+                    pattern += "(.+)";
+                    break;
+                default:
+                    pattern += "(.+)";
+                    break;
+            }
+            i = end;
+            continue;
         }
-        catch {
-            // If we can't resolve the symlink, proceed normally
-        }
+        pattern += escapeRegex(ch);
     }
-    const artifacts = [];
-    const entries = listFiles(skillsDir);
-    for (const entry of entries) {
-        const skillPath = path.join(skillsDir, entry);
-        if (!isDirectory(skillPath))
-            continue;
-        // Check for SKILL.md to confirm it's a valid skill
-        const skillMdPath = path.join(skillPath, "SKILL.md");
-        if (!fileExists(skillMdPath))
-            continue;
-        artifacts.push({
-            kind: "skill",
-            name: entry,
-            sourcePath: skillPath,
-            displayPath: path.join(locations.skills.dir, entry),
-            tool,
-            size: getSize(skillPath),
-            mtime: getMtime(skillPath),
-            destPath: `skills/${entry}`,
-        });
+    const regex = new RegExp(`^${pattern}$`);
+    const match = actualPath.match(regex);
+    if (!match)
+        return { matched: false, captures };
+    for (let i = 0; i < tokens.length; i += 1) {
+        captures[tokens[i]] = match[i + 1] ?? "";
     }
-    return artifacts;
+    return { matched: true, captures };
 }
 /**
  * Check if a file at project root is managed by loadout.
@@ -168,90 +290,244 @@ function isClaudeWrapper(filePath) {
         return false;
     }
 }
+/**
+ * Infer destination path for a discovered artifact.
+ *
+ * For built-ins we preserve canonical layout.
+ * For custom/future kinds we try several heuristics and keep whichever
+ * path is accepted by the kind's detect() predicate.
+ */
+function inferDestPath(kindId, toolName, strippedTargetPath, captures) {
+    const kind = registry.getKind(kindId);
+    if (!kind)
+        return null;
+    const stem = captures.stem || captures.name || path.basename(strippedTargetPath, path.extname(strippedTargetPath));
+    const ext = captures.ext || path.extname(strippedTargetPath);
+    // Canonical built-ins.
+    if (kindId === "instruction") {
+        return "instructions/AGENTS.base.md";
+    }
+    if (kindId === "rule") {
+        return `rules/${stem}.md`;
+    }
+    const candidates = [
+        strippedTargetPath,
+        `${toolName}/${strippedTargetPath}`,
+        `${kindId}/${strippedTargetPath}`,
+        `${kindId.replace(/-/g, "/")}/${strippedTargetPath}`,
+        `${kindId}/${stem}${ext}`,
+        `${kindId.replace(/-/g, "/")}/${stem}${ext}`,
+    ];
+    for (const candidate of candidates) {
+        const rel = toPosix(candidate).replace(/^\/+/, "");
+        if (kind.detect(rel)) {
+            return rel;
+        }
+    }
+    return null;
+}
+/**
+ * Check whether a given destination path already exists in .loadouts/.
+ */
+function artifactExistsInLoadout(loadoutPath, artifact) {
+    if (artifact.kind === "instruction") {
+        return false;
+    }
+    const kind = registry.getKind(artifact.kind);
+    if (!kind)
+        return false;
+    const destPath = path.join(loadoutPath, artifact.destPath);
+    return kind.layout === "dir" ? isDirectory(destPath) : fileExists(destPath);
+}
 /**
  * Discover instruction files at project root.
  * Only discovers files that are NOT managed by loadout.
  */
-function discoverInstructions(projectRoot, loadoutPath) {
+function discoverInstructions(scanRoot, loadoutPath) {
+    const kind = registry.getKind("instruction");
+    if (!kind)
+        return [];
     const artifacts = [];
     for (const filename of INSTRUCTION_FILES) {
-        const filePath = path.join(projectRoot, filename);
+        const filePath = path.join(scanRoot, filename);
         if (!fileExists(filePath))
             continue;
-        // Skip if this file is managed by loadout (symlink to .loadouts/)
         if (isManagedByLoadout(filePath, loadoutPath))
             continue;
-        // Skip auto-generated CLAUDE.md wrapper
         if (filename === "CLAUDE.md" && isClaudeWrapper(filePath))
             continue;
+        const metadata = readArtifactMetadata(filePath);
+        if (!metadata)
+            continue;
         artifacts.push({
             kind: "instruction",
             name: "AGENTS.md",
             sourcePath: filePath,
             displayPath: filename,
             tool: "project-root",
-            size: getSize(filePath),
-            mtime: getMtime(filePath),
-            destPath: "instructions/AGENTS.base.md", // Will be updated by install based on target loadout
+            size: metadata.size,
+            mtime: metadata.mtime,
+            destPath: "instructions/AGENTS.base.md",
         });
     }
     return artifacts;
 }
 /**
- * Check if an artifact already exists in .loadouts/.
- * For instructions, we DON'T filter them out since unmanaged files at project root
- * should be offered for import (to replace the template).
+ * Discover artifacts for one (tool, kind) pair by matching tool target templates.
  */
-function artifactExistsInLoadout(loadoutPath, artifact) {
-    // Instructions at project root are already filtered by discoverInstructions
-    // if they're managed. If they reach here, they're unmanaged and should be imported.
-    if (artifact.kind === "instruction") {
-        return false; // Always offer to import unmanaged instruction files
+function discoverForToolKind(scanRoot, scope, toolName, kindId, warnings) {
+    // Instruction files are discovered centrally at project root to avoid
+    // duplicate detection across tools that map to AGENTS.md / CLAUDE.md.
+    if (kindId === "instruction")
+        return [];
+    const tool = registry.getTool(toolName);
+    const kind = registry.getKind(kindId);
+    if (!tool || !kind)
+        return [];
+    const mapping = registry.resolveMapping(toolName, kindId);
+    if (!mapping)
+        return [];
+    const template = getScopeTemplate(mapping.path, scope);
+    const absoluteBasePath = resolveAbsoluteBasePath(scanRoot, tool.basePath[scope]);
+    const concreteTemplate = toPosix(template)
+        .replaceAll("{base}", toPosix(absoluteBasePath))
+        .replaceAll("{home}", toPosix(os.homedir()));
+    const parentTemplate = path.posix.dirname(concreteTemplate);
+    const leafTemplate = path.posix.basename(concreteTemplate);
+    const templateIsAbsolute = path.posix.isAbsolute(concreteTemplate);
+    // If parent path still has unresolved tokens, we cannot reliably scan.
+    if (/{[^}]+}/.test(parentTemplate)) {
+        warnings.push(`Skipped ${toolName}:${kindId} import scan (unsupported template parent: ${template})`);
+        return [];
     }
-    const destPath = path.join(loadoutPath, artifact.destPath);
-    return artifact.kind === "skill" ? isDirectory(destPath) : fileExists(destPath);
+    const parentAbs = templateIsAbsolute
+        ? parentTemplate
+        : path.join(scanRoot, parentTemplate);
+    if (!isDirectory(parentAbs))
+        return [];
+    let candidateAbsPaths = [];
+    if (kind.layout === "dir") {
+        // Prefer one-level dir scanning for templates like .../{name}.
+        if (leafTemplate === "{name}" || leafTemplate === "{stem}") {
+            candidateAbsPaths = listFiles(parentAbs)
+                .map((entry) => path.join(parentAbs, entry))
+                .filter((absolutePath) => isDirectory(absolutePath));
+        }
+        else if (!/{[^}]+}/.test(leafTemplate)) {
+            const absolutePath = path.join(parentAbs, leafTemplate);
+            if (isDirectory(absolutePath)) {
+                candidateAbsPaths = [absolutePath];
+            }
+        }
+    }
+    else {
+        if (/{relative}/.test(template)) {
+            candidateAbsPaths = walkDir(parentAbs).map((entry) => path.join(parentAbs, entry));
+        }
+        else if (!/{[^}]+}/.test(leafTemplate)) {
+            const absolutePath = path.join(parentAbs, leafTemplate);
+            if (fileExists(absolutePath)) {
+                candidateAbsPaths = [absolutePath];
+            }
+        }
+        else {
+            candidateAbsPaths = listFiles(parentAbs)
+                .map((entry) => path.join(parentAbs, entry))
+                .filter((absolutePath) => fileExists(absolutePath));
+        }
+    }
+    const artifacts = [];
+    for (const sourcePath of candidateAbsPaths) {
+        const sourcePathPosix = toPosix(sourcePath);
+        const matchPath = templateIsAbsolute
+            ? sourcePathPosix
+            : toPosix(path.relative(scanRoot, sourcePath));
+        const match = matchTemplatePath(concreteTemplate, matchPath);
+        if (!match.matched)
+            continue;
+        // Skip tool directories symlinked to another tool to avoid duplicates.
+        if (kind.layout === "dir" && isSymlink(sourcePath)) {
+            continue;
+        }
+        const basePrefix = `${toPosix(absoluteBasePath)}/`;
+        const stripped = sourcePathPosix.startsWith(basePrefix)
+            ? sourcePathPosix.slice(basePrefix.length)
+            : matchPath;
+        const destPath = inferDestPath(kindId, toolName, stripped, match.captures);
+        if (!destPath) {
+            warnings.push(`Skipped ${toolName}:${kindId} artifact (cannot infer loadout path for ${matchPath})`);
+            continue;
+        }
+        const metadata = readArtifactMetadata(sourcePath);
+        if (!metadata) {
+            warnings.push(`Skipped ${toolName}:${kindId} artifact (unreadable path: ${toDisplayPath(scanRoot, sourcePath)})`);
+            continue;
+        }
+        const name = kind.layout === "dir"
+            ? path.basename(destPath)
+            : path.basename(destPath, path.extname(destPath));
+        artifacts.push({
+            kind: kindId,
+            name,
+            sourcePath,
+            displayPath: toDisplayPath(scanRoot, sourcePath),
+            tool: toolName,
+            size: metadata.size,
+            mtime: metadata.mtime,
+            destPath,
+        });
+    }
+    return artifacts;
 }
+// ---------------------------------------------------------------------------
+// Public discovery API
+// ---------------------------------------------------------------------------
 /**
  * Discover all importable artifacts in a project.
  */
-export function discoverImportableArtifacts(projectRoot, options = {}) {
+export function discoverImportableArtifacts(scanRoot, options = {}) {
     const artifacts = [];
     const warnings = [];
-    const { tools, kinds, loadoutPath } = options;
-    // Filter tools if specified
+    const { scope = "project", tools, kinds, loadoutPath } = options;
+    const sourcePath = options.sourcePath ? path.resolve(options.sourcePath) : undefined;
+    const allTools = registry.allToolNames();
     const toolsToScan = tools
-        ? Object.keys(TOOL_LOCATIONS).filter((t) => tools.includes(t))
-        : Object.keys(TOOL_LOCATIONS);
-    // Discover from each tool directory
-    for (const tool of toolsToScan) {
-        const locations = TOOL_LOCATIONS[tool];
-        // Rules
-        if (!kinds || kinds.includes("rule")) {
-            artifacts.push(...discoverRules(projectRoot, tool, locations));
-        }
-        // Skills
-        if (!kinds || kinds.includes("skill")) {
-            artifacts.push(...discoverSkills(projectRoot, tool, locations));
+        ? allTools.filter((tool) => tools.includes(tool))
+        : allTools;
+    const allKinds = registry.allKinds().map((kind) => kind.id);
+    const kindsToScan = kinds && kinds.length > 0
+        ? allKinds.filter((kind) => kinds.includes(kind))
+        : allKinds;
+    for (const toolName of toolsToScan) {
+        for (const kindId of kindsToScan) {
+            artifacts.push(...discoverForToolKind(scanRoot, scope, toolName, kindId, warnings));
         }
     }
-    // Instructions (not tool-specific)
-    if (!kinds || kinds.includes("instruction")) {
-        artifacts.push(...discoverInstructions(projectRoot, loadoutPath));
+    // Keep root-level instruction import behavior for unmanaged AGENTS/CLAUDE files.
+    if (!kinds || kinds.length === 0 || kinds.includes("instruction")) {
+        artifacts.push(...discoverInstructions(scanRoot, loadoutPath));
+    }
+    if (sourcePath) {
+        artifacts.push(...discoverDirectSourceArtifacts(scanRoot, sourcePath, kinds));
     }
-    // Filter out artifacts that already exist in .loadouts/
-    const filteredArtifacts = loadoutPath
-        ? artifacts.filter((a) => !artifactExistsInLoadout(loadoutPath, a))
+    // Filter out artifacts already present in .loadouts/.
+    const existingFilteredArtifacts = loadoutPath
+        ? artifacts.filter((artifact) => !artifactExistsInLoadout(loadoutPath, artifact))
         : artifacts;
-    // Detect conflicts (same name from different tools)
-    const byName = new Map();
+    const sourceFilteredArtifacts = sourcePath
+        ? existingFilteredArtifacts.filter((artifact) => matchesSourcePath(artifact, sourcePath))
+        : existingFilteredArtifacts;
+    const filteredArtifacts = dedupeArtifacts(sourceFilteredArtifacts);
+    // Detect conflicts by canonical destination path.
+    const byDest = new Map();
     for (const artifact of filteredArtifacts) {
-        const key = `${artifact.kind}:${artifact.name}`;
-        const existing = byName.get(key) || [];
+        const key = `${artifact.kind}:${artifact.destPath}`;
+        const existing = byDest.get(key) ?? [];
         existing.push(artifact);
-        byName.set(key, existing);
+        byDest.set(key, existing);
     }
     const conflicts = new Map();
-    for (const [key, items] of byName) {
+    for (const [key, items] of byDest) {
         if (items.length > 1) {
             conflicts.set(key, items);
         }
@@ -262,12 +538,9 @@ export function discoverImportableArtifacts(projectRoot, options = {}) {
  * Group artifacts by kind for display.
  */
 export function groupByKind(artifacts) {
-    const groups = {
-        instruction: [],
-        rule: [],
-        skill: [],
-    };
+    const groups = {};
     for (const artifact of artifacts) {
+        groups[artifact.kind] ??= [];
         groups[artifact.kind].push(artifact);
     }
     return groups;