@hashicorp/kits 0.1.0

package/dist/adapters/base-adapter.js

@@ -0,0 +1,703 @@
+/**
+ * Base adapter class providing common functionality for harness adapters.
+ *
+ * This abstract class implements shared logic that all harness-specific adapters
+ * can use, reducing code duplication and ensuring consistent behavior across
+ * different AI agent harnesses.
+ */
+import * as path from "node:path";
+import { expandPath, pathExists, isDirectory, copyFile, copyDirectory, writeTransformed, readFile, createSimpleBackup, rollbackOperations, ensureDirectory, remove, } from "./file-operations.js";
+import { processToolTemplates as processTemplates } from "./tool-templating.js";
+import { parseCommandFrontmatter } from "./command-parser.js";
+import { mapAllowedTools, parseSkillFrontmatter, serializeSkillFrontmatter } from "./skill-frontmatter.js";
+import { mapSubagentTools, parseSubagentFrontmatter, serializeSubagentFrontmatter, } from "./subagent-frontmatter.js";
+import { resolveModelTemplate } from "./model-templating.js";
+/**
+ * Namespace separator for primitive names.
+ */
+export const NAMESPACE_SEPARATOR = ".";
+/**
+ * Abstract base class for kit adapters.
+ *
+ * Subclasses must implement abstract methods for harness-specific behavior
+ * while inheriting common functionality from this base class.
+ */
+export class BaseAdapter {
+    /**
+     * Filter subagent frontmatter for this harness.
+     */
+    filterSubagentFrontmatter(frontmatter, _metadata) {
+        return frontmatter;
+    }
+    /**
+     * Resolve canonical subagent hook bindings to harness-specific format.
+     */
+    mapSubagentHooks(frontmatter, _resolvedPrimitives, _kitName, _paths, _scope, _projectRoot) {
+        return frontmatter;
+    }
+    /**
+     * Filter skill frontmatter for this harness.
+     *
+     * Default behavior preserves all fields.
+     */
+    filterSkillFrontmatter(frontmatter, _metadata) {
+        return frontmatter;
+    }
+    /**
+     * Resolve canonical skill hook bindings to harness-specific format.
+     */
+    mapSkillHooks(frontmatter, _resolvedPrimitives, _kitName, _paths, _scope, _projectRoot) {
+        return frontmatter;
+    }
+    // ============================================================
+    // Common implementations
+    // ============================================================
+    /**
+     * Check if a kit is compatible with this harness at the given scope.
+     *
+     * @param kit - Kit manifest to check
+     * @param scope - Installation scope (defaults to "global")
+     */
+    checkCompatibility(kit, scope) {
+        const effectiveScope = scope ?? "global";
+        const supportedPrimitives = this.getSupportedPrimitives(effectiveScope);
+        const requiredPrimitives = kit.requires.primitives;
+        const missingPrimitives = requiredPrimitives.filter((p) => !supportedPrimitives.includes(p));
+        // Check for experimental primitives (hooks are often experimental)
+        const experimentalPrimitives = requiredPrimitives.filter((p) => p === "hooks" && supportedPrimitives.includes(p));
+        if (missingPrimitives.length > 0) {
+            return {
+                compatible: false,
+                missingPrimitives,
+                experimentalPrimitives,
+                message: `harness does not support at ${effectiveScope} scope: ${missingPrimitives.join(", ")}`,
+            };
+        }
+        if (experimentalPrimitives.length > 0) {
+            return {
+                compatible: true,
+                missingPrimitives: [],
+                experimentalPrimitives,
+                message: `harness has experimental support for: ${experimentalPrimitives.join(", ")}`,
+            };
+        }
+        return {
+            compatible: true,
+            missingPrimitives: [],
+            experimentalPrimitives: [],
+        };
+    }
+    /**
+     * Get a namespaced primitive name.
+     *
+     * Format: {kitName}.{primitiveName}
+     */
+    getNamespacedName(kitName, primitiveName) {
+        return `${kitName}${NAMESPACE_SEPARATOR}${primitiveName}`;
+    }
+    /**
+     * Parse a namespaced name into kit and primitive components.
+     */
+    parseNamespacedName(namespacedName) {
+        const separatorIndex = namespacedName.indexOf(NAMESPACE_SEPARATOR);
+        if (separatorIndex === -1) {
+            throw new Error(`invalid namespaced name; name=${namespacedName}`);
+        }
+        return {
+            kitName: namespacedName.substring(0, separatorIndex),
+            primitiveName: namespacedName.substring(separatorIndex + 1),
+        };
+    }
+    /**
+     * Process tool templates in content.
+     */
+    processToolTemplates(content) {
+        return processTemplates(content, this.getToolMapping());
+    }
+    /**
+     * Validate a kit against this harness's requirements.
+     */
+    validate(kit) {
+        const errors = [];
+        // Validate kit has a name
+        if (!kit.name || kit.name.trim() === "") {
+            errors.push({
+                field: "name",
+                message: "kit name is required",
+            });
+        }
+        // Validate kit has a version
+        if (!kit.version || kit.version.trim() === "") {
+            errors.push({
+                field: "version",
+                message: "kit version is required",
+            });
+        }
+        // Validate primitives structure
+        if (!kit.primitives) {
+            errors.push({
+                field: "primitives",
+                message: "kit must have primitives declaration",
+            });
+        }
+        // Validate each declared primitive type is in requires
+        const declaredTypes = Object.keys(kit.primitives || {});
+        const requiredTypes = kit.requires?.primitives || [];
+        for (const declaredType of declaredTypes) {
+            const primitives = kit.primitives?.[declaredType];
+            if (primitives && primitives.length > 0 && !requiredTypes.includes(declaredType)) {
+                errors.push({
+                    field: `requires.primitives`,
+                    message: `kit declares ${declaredType} primitives but does not list ${declaredType} in requires.primitives`,
+                });
+            }
+        }
+        return {
+            valid: errors.length === 0,
+            errors,
+        };
+    }
+    /**
+     * Install a kit to this harness.
+     */
+    async install(kit, resolvedPrimitives, options) {
+        const { dryRun = false, backup = true, onProgress, scope = "global", projectRoot, envResolutions, } = options;
+        const installedPrimitives = [];
+        const fileOperations = [];
+        const completedOps = [];
+        let backupPath;
+        const paths = this.getInstallationPaths(scope);
+        const configLocations = this.getConfigLocations(scope);
+        try {
+            // Phase 1: Create directories
+            onProgress?.({ scope, phase: "file", operation: "creating directories" });
+            const directories = [
+                paths.commands,
+                paths.skills,
+                paths.subagents,
+                paths.hooks,
+            ].filter(Boolean);
+            for (const dir of directories) {
+                if (!dryRun) {
+                    const expanded = scope === "project" && projectRoot
+                        ? path.join(projectRoot, dir.replace(/^\.\//, ""))
+                        : expandPath(dir);
+                    if (!pathExists(expanded)) {
+                        await ensureDirectory(expanded);
+                        completedOps.push({
+                            type: "directory",
+                            path: expanded,
+                            createdNew: true,
+                        });
+                    }
+                }
+            }
+            // Phase 2: Backup config if needed
+            if (backup && !dryRun) {
+                onProgress?.({ scope, phase: "file", operation: "creating backup" });
+                const configPath = scope === "project" && projectRoot
+                    ? path.join(projectRoot, configLocations.primary.replace(/^\.\//, ""))
+                    : expandPath(configLocations.primary);
+                backupPath = await createSimpleBackup(configPath);
+                if (backupPath) {
+                    completedOps.push({
+                        type: "backup",
+                        path: backupPath,
+                        createdNew: true,
+                    });
+                }
+            }
+            // Phase 3: Install each primitive
+            for (const primitive of resolvedPrimitives) {
+                const namespacedName = this.getNamespacedName(kit.name, primitive.name);
+                onProgress?.({
+                    scope,
+                    phase: "file",
+                    operation: "installing",
+                    primitive: primitive.name,
+                });
+                const result = await this.installPrimitive(kit.name, primitive, resolvedPrimitives, paths, dryRun, completedOps, scope, projectRoot);
+                const primitiveStatus = {
+                    type: primitive.type,
+                    name: primitive.name,
+                    namespacedName,
+                    status: result.existed ? "updated" : "installed",
+                    destination: result.destination,
+                };
+                if (primitive.ref !== undefined) {
+                    primitiveStatus.ref = primitive.ref;
+                }
+                if (primitive.resolvedVersion !== undefined) {
+                    primitiveStatus.resolvedVersion = primitive.resolvedVersion;
+                }
+                installedPrimitives.push(primitiveStatus);
+                fileOperations.push(...result.operations);
+            }
+            // Phase 4: Update configuration (MCP servers, hooks)
+            onProgress?.({ scope, phase: "config", operation: "updating configuration" });
+            const configResult = await this.updateConfiguration(kit, resolvedPrimitives, dryRun, completedOps, scope, projectRoot, envResolutions);
+            fileOperations.push(...configResult.operations);
+            // Phase 5: Update manifest
+            onProgress?.({ scope, phase: "manifest", operation: "updating manifest" });
+            const configPath = scope === "project" && projectRoot
+                ? path.join(projectRoot, configLocations.primary.replace(/^\.\//, ""))
+                : expandPath(configLocations.primary);
+            const successResult = {
+                success: true,
+                scope,
+                installedPrimitives,
+                fileOperations,
+                configPath,
+            };
+            if (projectRoot !== undefined && scope === "project") {
+                successResult.projectRoot = projectRoot;
+            }
+            if (backupPath !== undefined) {
+                successResult.backupPath = backupPath;
+            }
+            return successResult;
+        }
+        catch (error) {
+            // Rollback on failure
+            if (!dryRun && completedOps.length > 0) {
+                await rollbackOperations(completedOps);
+            }
+            const configPath = scope === "project" && projectRoot
+                ? path.join(projectRoot, configLocations.primary.replace(/^\.\//, ""))
+                : expandPath(configLocations.primary);
+            const errorResult = {
+                success: false,
+                scope,
+                installedPrimitives,
+                fileOperations,
+                configPath,
+                error: error instanceof Error ? error.message : String(error),
+            };
+            if (projectRoot !== undefined && scope === "project") {
+                errorResult.projectRoot = projectRoot;
+            }
+            if (backupPath !== undefined) {
+                errorResult.backupPath = backupPath;
+            }
+            return errorResult;
+        }
+    }
+    /**
+     * Install a single primitive.
+     *
+     * Subclasses may override for harness-specific behavior.
+     *
+     * @param kitName - Name of the kit being installed
+     * @param primitive - Resolved primitive to install
+     * @param resolvedPrimitives - All resolved primitives for the kit
+     * @param paths - Installation paths for the scope
+     * @param dryRun - If true, don't actually write files
+     * @param completedOps - Array to track completed operations for rollback
+     * @param scope - Installation scope
+     * @param projectRoot - Project root for project scope
+     */
+    async installPrimitive(kitName, primitive, resolvedPrimitives, paths, dryRun, completedOps, scope = "global", projectRoot) {
+        const namespacedName = this.getNamespacedName(kitName, primitive.name);
+        const operations = [];
+        // Helper to resolve path based on scope
+        const resolvePath = (p) => {
+            if (scope === "project" && projectRoot) {
+                return path.join(projectRoot, p.replace(/^\.\//, ""));
+            }
+            return expandPath(p);
+        };
+        let destination;
+        let existed = false;
+        switch (primitive.type) {
+            case "commands": {
+                destination = path.join(resolvePath(paths.commands), `${namespacedName}.md`);
+                existed = pathExists(destination);
+                if (!dryRun) {
+                    // Read content and validate canonical format
+                    const content = await readFile(primitive.sourcePath);
+                    // Validate command format (throws CommandParseError if invalid)
+                    const frontmatter = parseCommandFrontmatter(content);
+                    // Build metadata from validated frontmatter, preserving any existing metadata
+                    const metadata = {
+                        ...primitive.metadata,
+                        description: frontmatter.description,
+                    };
+                    if (frontmatter.argumentHint !== undefined) {
+                        metadata.argumentHint = frontmatter.argumentHint;
+                    }
+                    // Transform content using harness-specific adapter
+                    const transformed = this.transformCommand(content, metadata);
+                    // Process tool templates
+                    const { content: processedContent } = this.processToolTemplates(transformed.content);
+                    await writeTransformed(destination, processedContent);
+                    completedOps.push({
+                        type: "file",
+                        path: destination,
+                        createdNew: !existed,
+                    });
+                }
+                operations.push({
+                    operation: "transform",
+                    source: primitive.sourcePath,
+                    destination,
+                    success: true,
+                });
+                break;
+            }
+            case "skills": {
+                destination = path.join(resolvePath(paths.skills), namespacedName);
+                existed = pathExists(destination);
+                if (!dryRun) {
+                    const isDir = await isDirectory(primitive.sourcePath);
+                    const skillPath = isDir
+                        ? path.join(primitive.sourcePath, "SKILL.md")
+                        : primitive.sourcePath;
+                    if (isDir) {
+                        await copyDirectory(primitive.sourcePath, destination);
+                    }
+                    else {
+                        // Single file skill - create directory and copy
+                        await ensureDirectory(destination);
+                    }
+                    if (pathExists(skillPath)) {
+                        const content = await readFile(skillPath);
+                        const { frontmatter, body } = parseSkillFrontmatter(content);
+                        const nameValue = frontmatter["name"];
+                        const descriptionValue = frontmatter["description"];
+                        const allowedToolsValue = frontmatter["allowedTools"];
+                        const resolvedName = typeof nameValue === "string" && nameValue.length > 0
+                            ? nameValue
+                            : primitive.name;
+                        const resolvedDescription = typeof descriptionValue === "string"
+                            ? descriptionValue
+                            : primitive.metadata.description;
+                        const resolvedAllowedTools = typeof allowedToolsValue === "string" || Array.isArray(allowedToolsValue)
+                            ? allowedToolsValue
+                            : undefined;
+                        const metadata = { name: resolvedName };
+                        if (resolvedDescription !== undefined) {
+                            metadata.description = resolvedDescription;
+                        }
+                        if (resolvedAllowedTools !== undefined) {
+                            metadata.allowedTools = resolvedAllowedTools;
+                        }
+                        const updatedFrontmatter = {
+                            ...frontmatter,
+                            name: metadata.name,
+                        };
+                        if (typeof metadata.description === "string" && metadata.description.length > 0) {
+                            updatedFrontmatter["description"] = metadata.description;
+                        }
+                        const mappedFrontmatter = mapAllowedTools(updatedFrontmatter, this.getToolMapping());
+                        const modelResolvedFrontmatter = resolveModelTemplate(mappedFrontmatter, this.getModelMapping());
+                        const hooksResolvedFrontmatter = this.mapSkillHooks(modelResolvedFrontmatter, resolvedPrimitives, kitName, paths, scope, projectRoot);
+                        const filteredFrontmatter = this.filterSkillFrontmatter(hooksResolvedFrontmatter, metadata);
+                        const { content: processedBody } = this.processToolTemplates(body);
+                        const transformedContent = serializeSkillFrontmatter(filteredFrontmatter, processedBody);
+                        await writeTransformed(path.join(destination, "SKILL.md"), transformedContent);
+                    }
+                    else if (!isDir) {
+                        await copyFile(primitive.sourcePath, path.join(destination, "SKILL.md"));
+                    }
+                    completedOps.push({
+                        type: "directory",
+                        path: destination,
+                        createdNew: !existed,
+                    });
+                }
+                operations.push({
+                    operation: "transform",
+                    source: primitive.sourcePath,
+                    destination,
+                    success: true,
+                });
+                break;
+            }
+            case "subagents": {
+                if (!paths.subagents) {
+                    throw new Error(`harness does not support subagents; harness=${this.name}`);
+                }
+                destination = path.join(resolvePath(paths.subagents), `${namespacedName}.md`);
+                existed = pathExists(destination);
+                if (!dryRun) {
+                    const content = await readFile(primitive.sourcePath);
+                    let resolvedContent = content;
+                    const { frontmatter, body, hasFrontmatter } = parseSubagentFrontmatter(content);
+                    if (hasFrontmatter) {
+                        const toolMappedFrontmatter = mapSubagentTools(frontmatter, this.getToolMapping());
+                        const resolvedFrontmatter = resolveModelTemplate(toolMappedFrontmatter, this.getModelMapping());
+                        const hooksResolvedFrontmatter = this.mapSubagentHooks(resolvedFrontmatter, resolvedPrimitives, kitName, paths, scope, projectRoot);
+                        const filteredFrontmatter = this.filterSubagentFrontmatter(hooksResolvedFrontmatter, primitive.metadata);
+                        resolvedContent = serializeSubagentFrontmatter(filteredFrontmatter, body);
+                    }
+                    const transformed = this.transformSubagent(resolvedContent, primitive.metadata);
+                    const { content: processedContent } = this.processToolTemplates(transformed.content);
+                    await writeTransformed(destination, processedContent);
+                    completedOps.push({
+                        type: "file",
+                        path: destination,
+                        createdNew: !existed,
+                    });
+                }
+                operations.push({
+                    operation: "transform",
+                    source: primitive.sourcePath,
+                    destination,
+                    success: true,
+                });
+                break;
+            }
+            case "hooks": {
+                if (!paths.hooks) {
+                    throw new Error(`harness does not support hooks; harness=${this.name}`);
+                }
+                const instanceName = primitive.instanceName ?? namespacedName;
+                destination = path.join(resolvePath(paths.hooks), instanceName);
+                existed = pathExists(destination);
+                // Hook programs are installed during adapter configuration updates.
+                break;
+            }
+            case "mcp": {
+                // MCP servers are typically config-only, handled in updateConfiguration
+                const configLocs = this.getConfigLocations(scope);
+                const mcpPath = configLocs.mcp || configLocs.primary;
+                destination = resolvePath(mcpPath);
+                existed = pathExists(destination);
+                operations.push({
+                    operation: "merge",
+                    destination,
+                    success: true,
+                });
+                break;
+            }
+            default: {
+                throw new Error(`unsupported primitive type; type=${primitive.type}`);
+            }
+        }
+        return { destination, existed, operations };
+    }
+    /**
+     * Update harness configuration (MCP servers, hooks config).
+     *
+     * Subclasses should override for harness-specific config handling.
+     *
+     * @param kit - Kit manifest
+     * @param resolvedPrimitives - Resolved primitives to install
+     * @param dryRun - If true, don't actually write files
+     * @param completedOps - Array to track completed operations for rollback
+     * @param scope - Installation scope
+     * @param projectRoot - Project root for project scope
+     */
+    async updateConfiguration(_kit, _resolvedPrimitives, _dryRun, _completedOps, _scope = "global", _projectRoot, _envResolutions) {
+        // Default implementation does nothing
+        // Subclasses should override for MCP server and hook configuration
+        return { operations: [] };
+    }
+    /**
+     * Uninstall a kit from this harness.
+     *
+     * @param kitName - Name of the kit to uninstall
+     * @param options - Uninstall options including scope
+     */
+    async uninstall(kitName, options) {
+        const { dryRun = false, removeEmptyDirs = true, scope = "global", projectRoot } = options;
+        // Helper to resolve path based on scope
+        const resolvePath = (p) => {
+            if (scope === "project" && projectRoot) {
+                return path.join(projectRoot, p.replace(/^\.\//, ""));
+            }
+            return expandPath(p);
+        };
+        const configLocations = this.getConfigLocations(scope);
+        const configPath = resolvePath(configLocations.primary);
+        const removedPrimitives = [];
+        const removedFiles = [];
+        try {
+            // Get list of installed kits to find primitives to remove
+            const installedKits = await this.list(scope);
+            const kit = installedKits.find((k) => k.name === kitName);
+            if (!kit) {
+                return {
+                    success: false,
+                    removedPrimitives: [],
+                    removedFiles: [],
+                    configPath,
+                    error: `kit not found; name=${kitName}`,
+                };
+            }
+            // Remove each primitive
+            for (const primitive of kit.primitives) {
+                const filePath = scope === "project" && projectRoot
+                    ? path.join(projectRoot, primitive.location.replace(/^\.\//, ""))
+                    : expandPath(primitive.location);
+                if (pathExists(filePath)) {
+                    if (!dryRun) {
+                        await remove(filePath);
+                    }
+                    removedFiles.push(filePath);
+                    removedPrimitives.push(primitive.namespacedName);
+                }
+            }
+            // Remove empty directories if requested
+            if (removeEmptyDirs && !dryRun) {
+                const paths = this.getInstallationPaths(scope);
+                for (const dir of [paths.commands, paths.skills, paths.subagents, paths.hooks]) {
+                    if (dir) {
+                        const expanded = resolvePath(dir);
+                        // Try to remove if empty (will fail silently if not empty)
+                        try {
+                            const { rmdir } = await import("node:fs/promises");
+                            await rmdir(expanded);
+                        }
+                        catch {
+                            // Directory not empty or doesn't exist - ignore
+                        }
+                    }
+                }
+            }
+            return {
+                success: true,
+                removedPrimitives,
+                removedFiles,
+                configPath,
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                removedPrimitives,
+                removedFiles,
+                configPath,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    /**
+     * List installed kits.
+     *
+     * Subclasses should implement this based on how they track installations.
+     * The default implementation scans installation directories for namespaced files.
+     *
+     * @param scope - Installation scope (defaults to "global")
+     */
+    async list(scope) {
+        const effectiveScope = scope ?? "global";
+        // Default implementation scans directories
+        // Subclasses may override to use manifest or config-based tracking
+        const kits = new Map();
+        const paths = this.getInstallationPaths(effectiveScope);
+        // Scan commands directory
+        await this.scanDirectoryForPrimitives(paths.commands, "commands", ".md", kits);
+        // Scan skills directory (directories)
+        await this.scanDirectoryForPrimitives(paths.skills, "skills", "", kits, true);
+        // Scan subagents directory
+        if (paths.subagents) {
+            await this.scanDirectoryForPrimitives(paths.subagents, "subagents", ".md", kits);
+        }
+        // Scan hooks directory
+        if (paths.hooks) {
+            await this.scanDirectoryForPrimitives(paths.hooks, "hooks", "", kits);
+        }
+        return Array.from(kits.values());
+    }
+    /**
+     * Scan a directory for primitives and add to kit map.
+     */
+    async scanDirectoryForPrimitives(dirPath, primitiveType, extension, kits, isDirectory = false) {
+        const expanded = expandPath(dirPath);
+        if (!pathExists(expanded)) {
+            return;
+        }
+        const { readdir } = await import("node:fs/promises");
+        const entries = await readdir(expanded, { withFileTypes: true });
+        for (const entry of entries) {
+            // Check if entry matches our expected format
+            const entryName = isDirectory ? entry.name : entry.name.replace(extension, "");
+            if (!entryName.includes(NAMESPACE_SEPARATOR)) {
+                continue; // Not a namespaced primitive
+            }
+            try {
+                const { kitName, primitiveName } = this.parseNamespacedName(entryName);
+                if (!kits.has(kitName)) {
+                    kits.set(kitName, {
+                        name: kitName,
+                        version: "unknown", // Would need to read from manifest
+                        installedAt: "unknown",
+                        primitives: [],
+                    });
+                }
+                kits.get(kitName).primitives.push({
+                    type: primitiveType,
+                    name: primitiveName,
+                    namespacedName: entryName,
+                    location: path.join(expanded, entry.name),
+                });
+            }
+            catch {
+                // Invalid format - skip
+            }
+        }
+    }
+    /**
+     * Get the file extension for a primitive type.
+     */
+    getFileExtension(primitiveType) {
+        switch (primitiveType) {
+            case "commands":
+                return ".md";
+            case "skills":
+                return ""; // Skills are directories
+            case "subagents":
+                return ".md";
+            case "mcp":
+                return ".json";
+            case "hooks":
+                return "";
+            default:
+                return "";
+        }
+    }
+    /**
+     * Get the destination path for a primitive.
+     *
+     * @param primitiveType - Type of primitive
+     * @param namespacedName - Namespaced name of the primitive
+     * @param scope - Installation scope (defaults to "global")
+     * @param projectRoot - Project root for project scope
+     */
+    getDestinationPath(primitiveType, namespacedName, scope = "global", projectRoot) {
+        const paths = this.getInstallationPaths(scope);
+        const ext = this.getFileExtension(primitiveType);
+        // Helper to resolve path based on scope
+        const resolvePath = (p) => {
+            if (scope === "project" && projectRoot) {
+                return path.join(projectRoot, p.replace(/^\.\//, ""));
+            }
+            return expandPath(p);
+        };
+        switch (primitiveType) {
+            case "commands":
+                return path.join(resolvePath(paths.commands), `${namespacedName}${ext}`);
+            case "skills":
+                return path.join(resolvePath(paths.skills), namespacedName);
+            case "subagents":
+                if (!paths.subagents) {
+                    throw new Error("subagents not supported");
+                }
+                return path.join(resolvePath(paths.subagents), `${namespacedName}${ext}`);
+            case "hooks":
+                if (!paths.hooks) {
+                    throw new Error("hooks not supported");
+                }
+                return path.join(resolvePath(paths.hooks), `${namespacedName}${ext}`);
+            case "mcp":
+                {
+                    const config = this.getConfigLocations(scope);
+                    return resolvePath(config.mcp || config.primary);
+                }
+            default:
+                throw new Error(`unsupported primitive type; type=${primitiveType}`);
+        }
+    }
+}
+//# sourceMappingURL=base-adapter.js.map