@dexto/core 1.2.4 → 1.2.5

package/dist/agent/registry/registry.cjs

@@ -1,479 +0,0 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var registry_exports = {};
-__export(registry_exports, {
-  LocalAgentRegistry: () => LocalAgentRegistry,
-  getAgentRegistry: () => getAgentRegistry
-});
-module.exports = __toCommonJS(registry_exports);
-var import_fs = require("fs");
-var import_fs2 = require("fs");
-var import_path = __toESM(require("path"), 1);
-var import_logger = require("../../logger/index.cjs");
-var import_path2 = require("../../utils/path.cjs");
-var import_loader = require("../../preferences/loader.cjs");
-var import_writer = require("../../config/writer.cjs");
-var import_types = require("./types.js");
-var import_errors = require("./errors.js");
-var import_user_registry = require("./user-registry.js");
-let cachedRegistry = null;
-class LocalAgentRegistry {
-  _registry = null;
-  /**
-   * Lazy load registry from JSON file
-   */
-  getRegistry() {
-    if (this._registry === null) {
-      this._registry = this.loadRegistry();
-    }
-    return this._registry;
-  }
-  /**
-   * Load and merge bundled + user registries
-   * Uses fail-fast approach - throws RegistryError for any loading issues
-   */
-  loadRegistry() {
-    let jsonPath;
-    try {
-      jsonPath = (0, import_path2.resolveBundledScript)("agents/agent-registry.json");
-    } catch (error) {
-      throw import_errors.RegistryError.registryNotFound(
-        "agents/agent-registry.json",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    if (!(0, import_fs.existsSync)(jsonPath)) {
-      throw import_errors.RegistryError.registryNotFound(jsonPath, "File doesn't exist");
-    }
-    let bundledRegistry;
-    try {
-      const jsonData = (0, import_fs.readFileSync)(jsonPath, "utf-8");
-      const rawRegistry = JSON.parse(jsonData);
-      bundledRegistry = import_types.RegistrySchema.parse((0, import_types.normalizeRegistryJson)(rawRegistry));
-    } catch (error) {
-      throw import_errors.RegistryError.registryParseError(
-        jsonPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    const userRegistry = (0, import_user_registry.loadUserRegistry)();
-    const merged = (0, import_user_registry.mergeRegistries)(bundledRegistry, userRegistry);
-    import_logger.logger.debug(
-      `Loaded registry: ${Object.keys(bundledRegistry.agents).length} bundled, ${Object.keys(userRegistry.agents).length} custom`
-    );
-    return merged;
-  }
-  /**
-   * Check if agent exists in registry by ID
-   */
-  hasAgent(agentId) {
-    const registry = this.getRegistry();
-    return agentId in registry.agents;
-  }
-  /**
-   * Get available agents with their metadata from registry
-   */
-  getAvailableAgents() {
-    const registry = this.getRegistry();
-    return registry.agents;
-  }
-  /**
-   * Validate custom agent ID doesn't conflict with bundled registry
-   * @throws RegistryError if ID conflicts with builtin agent
-   */
-  validateCustomAgentId(agentId) {
-    let jsonPath;
-    try {
-      jsonPath = (0, import_path2.resolveBundledScript)("agents/agent-registry.json");
-    } catch (error) {
-      throw import_errors.RegistryError.registryNotFound(
-        "agents/agent-registry.json",
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-    try {
-      const jsonData = (0, import_fs.readFileSync)(jsonPath, "utf-8");
-      const bundledRegistry = import_types.RegistrySchema.parse(
-        (0, import_types.normalizeRegistryJson)(JSON.parse(jsonData))
-      );
-      if (agentId in bundledRegistry.agents) {
-        throw import_errors.RegistryError.customAgentNameConflict(agentId);
-      }
-    } catch (error) {
-      if (error instanceof Error && /name conflicts with builtin agent/.test(error.message)) {
-        throw error;
-      }
-      throw import_errors.RegistryError.registryParseError(
-        jsonPath,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Resolve main config file for installed agent
-   * Handles both directory agents (with main field) and single-file agents
-   */
-  resolveMainConfig(agentDir, agentId) {
-    const registry = this.getRegistry();
-    const agentData = registry.agents[agentId];
-    if (!agentData) {
-      const available = Object.keys(registry.agents);
-      throw import_errors.RegistryError.agentNotFound(agentId, available);
-    }
-    if (agentData.source.endsWith("/")) {
-      if (!agentData.main) {
-        throw import_errors.RegistryError.agentInvalidEntry(
-          agentId,
-          "directory entry missing main field"
-        );
-      }
-      const mainConfigPath = import_path.default.join(agentDir, agentData.main);
-      if (!(0, import_fs.existsSync)(mainConfigPath)) {
-        throw import_errors.RegistryError.mainConfigMissing(agentId, mainConfigPath);
-      }
-      return mainConfigPath;
-    } else {
-      const filename = import_path.default.basename(agentData.source);
-      const configPath = import_path.default.join(agentDir, filename);
-      if (!(0, import_fs.existsSync)(configPath)) {
-        throw import_errors.RegistryError.configNotFound(configPath);
-      }
-      return configPath;
-    }
-  }
-  /**
-   * Install agent atomically using temp + rename pattern
-   * @param agentId ID of the agent to install
-   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
-   */
-  async installAgent(agentId, injectPreferences = true) {
-    import_logger.logger.info(`Installing agent: ${agentId}`);
-    const registry = this.getRegistry();
-    const agentData = registry.agents[agentId];
-    if (!agentData) {
-      const available = Object.keys(registry.agents);
-      throw import_errors.RegistryError.agentNotFound(agentId, available);
-    }
-    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    const targetDir = import_path.default.resolve(globalAgentsDir, agentId);
-    const relTarget = import_path.default.relative(globalAgentsDir, targetDir);
-    if (relTarget.startsWith("..") || import_path.default.isAbsolute(relTarget)) {
-      throw import_errors.RegistryError.installationFailed(
-        agentId,
-        "invalid agentId: path traversal detected"
-      );
-    }
-    if ((0, import_fs.existsSync)(targetDir)) {
-      import_logger.logger.info(`Agent '${agentId}' already installed`);
-      return this.resolveMainConfig(targetDir, agentId);
-    }
-    await import_fs2.promises.mkdir(globalAgentsDir, { recursive: true });
-    const sourcePath = (0, import_path2.resolveBundledScript)(`agents/${agentData.source}`);
-    const tempDir = `${targetDir}.tmp.${Date.now()}`;
-    try {
-      if (agentData.source.endsWith("/")) {
-        await (0, import_path2.copyDirectory)(sourcePath, tempDir);
-      } else {
-        await import_fs2.promises.mkdir(tempDir, { recursive: true });
-        const targetFile = import_path.default.join(tempDir, import_path.default.basename(sourcePath));
-        await import_fs2.promises.copyFile(sourcePath, targetFile);
-      }
-      const mainConfigPath = this.resolveMainConfig(tempDir, agentId);
-      if (!(0, import_fs.existsSync)(mainConfigPath)) {
-        throw import_errors.RegistryError.installationValidationFailed(agentId, mainConfigPath);
-      }
-      await import_fs2.promises.rename(tempDir, targetDir);
-      import_logger.logger.info(`\u2713 Installed agent '${agentId}' to ${targetDir}`);
-      if (injectPreferences) {
-        try {
-          const preferences = await (0, import_loader.loadGlobalPreferences)();
-          await (0, import_writer.writePreferencesToAgent)(targetDir, preferences);
-          import_logger.logger.info(`\u2713 Applied global preferences to installed agent '${agentId}'`);
-        } catch (error) {
-          import_logger.logger.warn(
-            `Failed to inject preferences to '${agentId}': ${error instanceof Error ? error.message : String(error)}`
-          );
-          console.log(
-            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentId}' - agent will use bundled settings`
-          );
-        }
-      } else {
-        import_logger.logger.info(
-          `Skipped preference injection for '${agentId}' (injectPreferences=false)`
-        );
-      }
-      return this.resolveMainConfig(targetDir, agentId);
-    } catch (error) {
-      try {
-        if ((0, import_fs.existsSync)(tempDir)) {
-          await import_fs2.promises.rm(tempDir, { recursive: true, force: true });
-        }
-      } catch (cleanupError) {
-        import_logger.logger.error(
-          `Failed to clean up temp directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}. Skipping cleanup...`
-        );
-      }
-      throw import_errors.RegistryError.installationFailed(
-        agentId,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Install a custom agent from a local file path
-   * @param agentId Unique identifier for the custom agent
-   * @param sourcePath Absolute path to agent YAML file or directory
-   * @param metadata Agent metadata (name for display, description, author, tags, main)
-   * @param injectPreferences Whether to inject global preferences (default: true)
-   * @returns Path to the installed agent's main config file
-   */
-  async installCustomAgentFromPath(agentId, sourcePath, metadata, injectPreferences = true) {
-    import_logger.logger.info(`Installing custom agent '${agentId}' from ${sourcePath}`);
-    this.validateCustomAgentId(agentId);
-    if (!(0, import_fs.existsSync)(sourcePath)) {
-      throw import_errors.RegistryError.configNotFound(sourcePath);
-    }
-    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    const targetDir = import_path.default.resolve(globalAgentsDir, agentId);
-    const relTarget = import_path.default.relative(globalAgentsDir, targetDir);
-    if (relTarget.startsWith("..") || import_path.default.isAbsolute(relTarget)) {
-      throw import_errors.RegistryError.installationFailed(
-        agentId,
-        "invalid agentId: path traversal detected"
-      );
-    }
-    if ((0, import_fs.existsSync)(targetDir)) {
-      throw import_errors.RegistryError.agentAlreadyExists(agentId);
-    }
-    await import_fs2.promises.mkdir(globalAgentsDir, { recursive: true });
-    const stats = await import_fs2.promises.stat(sourcePath);
-    const isDirectory = stats.isDirectory();
-    const configFileName = isDirectory ? void 0 : `${agentId}.yml`;
-    if (!metadata.description) {
-      throw import_errors.RegistryError.installationFailed(agentId, "description is required");
-    }
-    if (isDirectory && !metadata.main) {
-      throw import_errors.RegistryError.installationFailed(
-        agentId,
-        "main field is required for directory-based agents"
-      );
-    }
-    const displayName = metadata.name || agentId.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
-    const registryEntry = {
-      id: agentId,
-      name: displayName,
-      description: metadata.description,
-      author: metadata.author,
-      tags: metadata.tags,
-      source: isDirectory ? `${agentId}/` : configFileName,
-      main: metadata.main
-    };
-    const tempDir = `${targetDir}.tmp.${Date.now()}`;
-    try {
-      if (isDirectory) {
-        await (0, import_path2.copyDirectory)(sourcePath, tempDir);
-      } else {
-        await import_fs2.promises.mkdir(tempDir, { recursive: true });
-        const targetFile = import_path.default.join(tempDir, configFileName);
-        await import_fs2.promises.copyFile(sourcePath, targetFile);
-      }
-      const tempMainConfigPath = isDirectory ? import_path.default.join(tempDir, metadata.main) : import_path.default.join(tempDir, configFileName);
-      if (!(0, import_fs.existsSync)(tempMainConfigPath)) {
-        throw import_errors.RegistryError.installationValidationFailed(agentId, tempMainConfigPath);
-      }
-      await import_fs2.promises.rename(tempDir, targetDir);
-      import_logger.logger.info(`\u2713 Installed custom agent '${agentId}' to ${targetDir}`);
-      const mainConfigPath = isDirectory && metadata.main ? import_path.default.join(targetDir, metadata.main) : import_path.default.join(targetDir, configFileName);
-      try {
-        await (0, import_user_registry.addAgentToUserRegistry)(agentId, registryEntry);
-        import_logger.logger.info(`\u2713 Added '${agentId}' to user registry`);
-        this._registry = null;
-      } catch (registryError) {
-        try {
-          if ((0, import_fs.existsSync)(targetDir)) {
-            await import_fs2.promises.rm(targetDir, { recursive: true, force: true });
-            import_logger.logger.info(`Rolled back installation: removed ${targetDir}`);
-          }
-        } catch (rollbackError) {
-          import_logger.logger.error(
-            `Rollback failed for '${agentId}': ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}`
-          );
-        }
-        throw registryError;
-      }
-      if (injectPreferences) {
-        try {
-          const preferences = await (0, import_loader.loadGlobalPreferences)();
-          await (0, import_writer.writePreferencesToAgent)(targetDir, preferences);
-          import_logger.logger.info(`\u2713 Applied global preferences to custom agent '${agentId}'`);
-        } catch (error) {
-          import_logger.logger.warn(
-            `Failed to inject preferences to '${agentId}': ${error instanceof Error ? error.message : String(error)}`
-          );
-          console.log(
-            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentId}' - agent will use default settings`
-          );
-        }
-      }
-      return mainConfigPath;
-    } catch (error) {
-      try {
-        if ((0, import_fs.existsSync)(tempDir)) {
-          await import_fs2.promises.rm(tempDir, { recursive: true, force: true });
-        }
-      } catch (cleanupError) {
-        import_logger.logger.error(
-          `Failed to clean up temp directory: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}. Skipping cleanup...`
-        );
-      }
-      throw import_errors.RegistryError.installationFailed(
-        agentId,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-  /**
-   * Resolve a registry agent ID to a config path
-   * NOTE: Only handles registry IDs, not file paths (routing done in loadAgentConfig)
-   * Handles installing agent if needed
-   * @param agentId ID of the agent to resolve
-   * @param autoInstall Whether to automatically install missing agents from registry (default: true)
-   * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
-   */
-  async resolveAgent(agentId, autoInstall = true, injectPreferences = true) {
-    import_logger.logger.debug(`Resolving registry agent: ${agentId}`);
-    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    const installedPath = import_path.default.resolve(globalAgentsDir, agentId);
-    const relInstalled = import_path.default.relative(globalAgentsDir, installedPath);
-    if (relInstalled.startsWith("..") || import_path.default.isAbsolute(relInstalled)) {
-      throw import_errors.RegistryError.agentNotFound(agentId, Object.keys(this.getRegistry().agents));
-    }
-    if ((0, import_fs.existsSync)(installedPath)) {
-      const mainConfig = this.resolveMainConfig(installedPath, agentId);
-      import_logger.logger.debug(`Resolved installed agent '${agentId}' to: ${mainConfig}`);
-      return mainConfig;
-    }
-    import_logger.logger.debug(`Agent '${agentId}' not found in installed path: ${installedPath}`);
-    if (this.hasAgent(agentId)) {
-      if (autoInstall) {
-        import_logger.logger.info(`Installing agent '${agentId}' from registry...`);
-        return await this.installAgent(agentId, injectPreferences);
-      } else {
-        const registry2 = this.getRegistry();
-        const available2 = Object.keys(registry2.agents);
-        throw import_errors.RegistryError.agentNotInstalledAutoInstallDisabled(agentId, available2);
-      }
-    }
-    const registry = this.getRegistry();
-    const available = Object.keys(registry.agents);
-    throw import_errors.RegistryError.agentNotFound(agentId, available);
-  }
-  /**
-   * Get list of currently installed agents
-   */
-  async getInstalledAgents() {
-    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    if (!(0, import_fs.existsSync)(globalAgentsDir)) {
-      return [];
-    }
-    try {
-      const entries = await import_fs2.promises.readdir(globalAgentsDir, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".tmp") && !name.includes(".tmp."));
-    } catch (error) {
-      import_logger.logger.error(`Failed to read installed agents directory: ${error}`);
-      return [];
-    }
-  }
-  /**
-   * Check if an agent is safe to uninstall (not the default agent from preferences)
-   */
-  async isAgentSafeToUninstall(agentId) {
-    try {
-      const preferences = await (0, import_loader.loadGlobalPreferences)();
-      const defaultAgent = preferences.defaults.defaultAgent;
-      return agentId !== defaultAgent;
-    } catch {
-      import_logger.logger.warn("Could not load preferences, using fallback protection for default-agent");
-      return agentId !== "default-agent";
-    }
-  }
-  /**
-   * Uninstall an agent by removing its directory
-   * For custom agents: also removes from user registry
-   * For builtin agents: only removes from disk
-   * @param agentId ID of the agent to uninstall
-   * @param force Whether to force uninstall even if agent is protected (default: false)
-   */
-  async uninstallAgent(agentId, force = false) {
-    const globalAgentsDir = (0, import_path2.getDextoGlobalPath)("agents");
-    const agentDir = import_path.default.resolve(globalAgentsDir, agentId);
-    const relAgent = import_path.default.relative(globalAgentsDir, agentDir);
-    if (relAgent.startsWith("..") || import_path.default.isAbsolute(relAgent)) {
-      throw import_errors.RegistryError.uninstallationFailed(
-        agentId,
-        "invalid agentId: path traversal detected"
-      );
-    }
-    import_logger.logger.info(`Uninstalling agent: ${agentId} from ${agentDir}`);
-    if (!(0, import_fs.existsSync)(agentDir)) {
-      throw import_errors.RegistryError.agentNotInstalled(agentId);
-    }
-    if (!force && !await this.isAgentSafeToUninstall(agentId)) {
-      throw import_errors.RegistryError.agentProtected(agentId);
-    }
-    const registry = this.getRegistry();
-    const agentData = registry.agents[agentId];
-    const isCustomAgent = agentData?.type === "custom";
-    try {
-      await import_fs2.promises.rm(agentDir, { recursive: true, force: true });
-      import_logger.logger.info(`\u2713 Removed agent '${agentId}' from ${agentDir}`);
-      if (isCustomAgent) {
-        await (0, import_user_registry.removeAgentFromUserRegistry)(agentId);
-        import_logger.logger.info(`\u2713 Removed custom agent '${agentId}' from user registry`);
-        this._registry = null;
-      }
-    } catch (error) {
-      throw import_errors.RegistryError.uninstallationFailed(
-        agentId,
-        error instanceof Error ? error.message : String(error)
-      );
-    }
-  }
-}
-function getAgentRegistry() {
-  if (cachedRegistry === null) {
-    cachedRegistry = new LocalAgentRegistry();
-  }
-  return cachedRegistry;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  LocalAgentRegistry,
-  getAgentRegistry
-});

package/dist/agent/registry/registry.d.ts

@@ -1,130 +0,0 @@
-import { Registry, AgentRegistry, AgentRegistryEntry } from './types.js';
-/**
- * Local agent registry implementation
- *
- * TODO: ARCHITECTURAL REFACTOR - Move registry, preferences, and agent resolution to CLI
- *
- * PROBLEM: Registry operations are CLI concerns but live in Core, causing:
- * - Missing analytics for auto-install (when running `dexto`, registry installs agents but doesn't track)
- * - Wrong separation of concerns (Core = execution engine, not discovery/setup)
- * - Registry manages ~/.dexto/agents filesystem which is CLI-level setup
- *
- * THE RIGHT ARCHITECTURE:
- *
- * Move to CLI:
- * 1. Agent Registry (packages/core/src/agent/registry/) → packages/cli/src/registry/
- *    - installAgent(), uninstallAgent(), resolveAgent(), listAgents()
- *    - Can directly call capture() for analytics
- *    - Manages ~/.dexto/agents installation directory
- *
- * 2. Global Preferences (packages/core/src/preferences/) → packages/cli/src/preferences/
- *    - User's default LLM, model, default agent
- *    - Used by `dexto setup` command
- *    - Manages ~/.dexto/preferences.json
- *
- * 3. Agent Resolution (packages/core/src/config/agent-resolver.ts) → packages/cli/src/agent-resolver.ts
- *    - Discovery logic: check registry, trigger installs, apply preferences
- *    - Returns resolved config PATH to core
- *
- * Core keeps:
- * - config/loader.ts - Load YAML from path
- * - config/schemas.ts - Zod validation
- * - Agent execution (DextoAgent, LLM, tools, MCP)
- *
- * FLOW AFTER REFACTOR:
- * CLI index.ts:
- *   → CLI: resolveAgentPath() (discovery logic)
- *     → CLI: registry.resolveAgent()
- *       → CLI: registry.installAgent() if needed
- *       → CLI: capture('dexto_install_agent', ...) ✓ Natural!
- *   → Core: new DextoAgent(configPath) (just loads & runs)
- *
- * BENEFITS:
- * - Clear separation: CLI = setup/discovery, Core = execution
- * - Analytics naturally colocated with operations
- * - Core is portable (no CLI dependencies)
- * - No circular deps (CLI → Core, correct direction)
- *
- * ESTIMATE: ~3-4 hours (mostly moving code + updating imports)
- */
-export declare class LocalAgentRegistry implements AgentRegistry {
-    private _registry;
-    /**
-     * Lazy load registry from JSON file
-     */
-    getRegistry(): Registry;
-    /**
-     * Load and merge bundled + user registries
-     * Uses fail-fast approach - throws RegistryError for any loading issues
-     */
-    private loadRegistry;
-    /**
-     * Check if agent exists in registry by ID
-     */
-    hasAgent(agentId: string): boolean;
-    /**
-     * Get available agents with their metadata from registry
-     */
-    getAvailableAgents(): Record<string, AgentRegistryEntry>;
-    /**
-     * Validate custom agent ID doesn't conflict with bundled registry
-     * @throws RegistryError if ID conflicts with builtin agent
-     */
-    private validateCustomAgentId;
-    /**
-     * Resolve main config file for installed agent
-     * Handles both directory agents (with main field) and single-file agents
-     */
-    resolveMainConfig(agentDir: string, agentId: string): string;
-    /**
-     * Install agent atomically using temp + rename pattern
-     * @param agentId ID of the agent to install
-     * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
-     */
-    installAgent(agentId: string, injectPreferences?: boolean): Promise<string>;
-    /**
-     * Install a custom agent from a local file path
-     * @param agentId Unique identifier for the custom agent
-     * @param sourcePath Absolute path to agent YAML file or directory
-     * @param metadata Agent metadata (name for display, description, author, tags, main)
-     * @param injectPreferences Whether to inject global preferences (default: true)
-     * @returns Path to the installed agent's main config file
-     */
-    installCustomAgentFromPath(agentId: string, sourcePath: string, metadata: {
-        name?: string;
-        description: string;
-        author: string;
-        tags: string[];
-        main?: string;
-    }, injectPreferences?: boolean): Promise<string>;
-    /**
-     * Resolve a registry agent ID to a config path
-     * NOTE: Only handles registry IDs, not file paths (routing done in loadAgentConfig)
-     * Handles installing agent if needed
-     * @param agentId ID of the agent to resolve
-     * @param autoInstall Whether to automatically install missing agents from registry (default: true)
-     * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
-     */
-    resolveAgent(agentId: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
-    /**
-     * Get list of currently installed agents
-     */
-    getInstalledAgents(): Promise<string[]>;
-    /**
-     * Check if an agent is safe to uninstall (not the default agent from preferences)
-     */
-    private isAgentSafeToUninstall;
-    /**
-     * Uninstall an agent by removing its directory
-     * For custom agents: also removes from user registry
-     * For builtin agents: only removes from disk
-     * @param agentId ID of the agent to uninstall
-     * @param force Whether to force uninstall even if agent is protected (default: false)
-     */
-    uninstallAgent(agentId: string, force?: boolean): Promise<void>;
-}
-/**
- * Get cached registry instance (singleton pattern)
- */
-export declare function getAgentRegistry(): LocalAgentRegistry;
-//# sourceMappingURL=registry.d.ts.map

package/dist/agent/registry/registry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/agent/registry/registry.ts"],"names":[],"mappings":"AAOA,OAAO,EACH,QAAQ,EAER,aAAa,EACb,kBAAkB,EAErB,MAAM,YAAY,CAAC;AAYpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,qBAAa,kBAAmB,YAAW,aAAa;IACpD,OAAO,CAAC,SAAS,CAAyB;IAE1C;;OAEG;IACH,WAAW,IAAI,QAAQ;IAOvB;;;OAGG;IACH,OAAO,CAAC,YAAY;IAyCpB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAKlC;;OAEG;IACH,kBAAkB,IAAI,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC;IAKxD;;;OAGG;IACH,OAAO,CAAC,qBAAqB;IAgC7B;;;OAGG;IACH,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM;IAqC5D;;;;OAIG;IACG,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,iBAAiB,GAAE,OAAc,GAAG,OAAO,CAAC,MAAM,CAAC;IAqGvF;;;;;;;OAOG;IACG,0BAA0B,CAC5B,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE;QACN,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,EAAE,MAAM,EAAE,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;KACjB,EACD,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC;IAqKlB;;;;;;;OAOG;IACG,YAAY,CACd,OAAO,EAAE,MAAM,EACf,WAAW,GAAE,OAAc,EAC3B,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC;IAsClB;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,MAAM,EAAE,CAAC;IAsB7C;;OAEG;YACW,sBAAsB;IAYpC;;;;;;OAMG;IACG,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,GAAE,OAAe,GAAG,OAAO,CAAC,IAAI,CAAC;CA8C/E;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,kBAAkB,CAKrD"}