@dexto/core 1.1.10 → 1.2.0

package/dist/Dexto.js

@@ -0,0 +1,228 @@
+import "./chunk-C6A6W6XS.js";
+import { logger } from "./logger/index.js";
+import { getAgentRegistry } from "./agent/registry/registry.js";
+import { loadAgentConfig } from "./config/loader.js";
+import { AgentError } from "./agent/errors.js";
+import { DextoAgent } from "./agent/DextoAgent.js";
+import { deriveDisplayName } from "./agent/registry/types.js";
+class Dexto {
+  /**
+   * Lists available and installed agents from the registry.
+   * Returns a structured object containing both installed and available agents,
+   * along with metadata like descriptions, authors, and tags.
+   *
+   * @returns Promise resolving to object with installed and available agent lists
+   *
+   * @example
+   * ```typescript
+   * const agents = await Dexto.listAgents();
+   * console.log(agents.installed); // ['default', 'my-custom-agent']
+   * console.log(agents.available); // [{ name: 'productivity', description: '...', ... }]
+   * console.log(agents.current?.name); // 'default'
+   * ```
+   */
+  static async listAgents() {
+    const agentRegistry = getAgentRegistry();
+    const availableMap = agentRegistry.getAvailableAgents();
+    const installedNames = await agentRegistry.getInstalledAgents();
+    const installed = await Promise.all(
+      installedNames.map(async (agentId) => {
+        const registryEntry = availableMap[agentId];
+        if (registryEntry) {
+          return {
+            id: agentId,
+            name: registryEntry.name,
+            description: registryEntry.description,
+            author: registryEntry.author,
+            tags: registryEntry.tags,
+            type: registryEntry.type
+          };
+        } else {
+          try {
+            const config = await loadAgentConfig(agentId);
+            const author = config.agentCard?.provider?.organization;
+            const result = {
+              id: agentId,
+              name: typeof config.agentCard?.name === "string" ? config.agentCard.name : deriveDisplayName(agentId),
+              description: config.agentCard?.description || "Local agent",
+              tags: [],
+              type: "custom"
+              // Assume custom if not in registry
+            };
+            if (author) {
+              result.author = author;
+            }
+            return result;
+          } catch {
+            const result = {
+              id: agentId,
+              name: deriveDisplayName(agentId),
+              description: "Local agent (config unavailable)",
+              tags: [],
+              type: "custom"
+              // Assume custom if not in registry
+            };
+            return result;
+          }
+        }
+      })
+    );
+    const available = Object.entries(availableMap).filter(([agentId]) => !installedNames.includes(agentId)).map(([agentId, entry]) => ({
+      id: agentId,
+      name: entry.name,
+      description: entry.description,
+      author: entry.author,
+      tags: entry.tags,
+      type: entry.type
+    }));
+    return {
+      installed,
+      available,
+      current: { id: null, name: null }
+      // TODO: Track current agent name
+    };
+  }
+  /**
+   * Installs an agent from the registry.
+   * Downloads and sets up the specified agent, making it available for use.
+   *
+   * @param agentName The name of the agent to install from the registry
+   * @returns Promise that resolves when installation is complete
+   *
+   * @throws {AgentError} When agent is not found in registry or installation fails
+   *
+   * @example
+   * ```typescript
+   * await Dexto.installAgent('productivity');
+   * console.log('Productivity agent installed successfully');
+   * ```
+   */
+  static async installAgent(agentName) {
+    const agentRegistry = getAgentRegistry();
+    if (!agentRegistry.hasAgent(agentName)) {
+      throw AgentError.apiValidationError(`Agent '${agentName}' not found in registry`);
+    }
+    try {
+      await agentRegistry.installAgent(agentName, true);
+      logger.info(`Successfully installed agent: ${agentName}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to install agent ${agentName}: ${errorMessage}`);
+      throw AgentError.apiValidationError(
+        `Installation failed for agent '${agentName}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Installs a custom agent from a local file or directory path.
+   * Creates a new custom agent entry in the user registry with provided metadata.
+   *
+   * @param agentName The name to use for the custom agent (must be unique)
+   * @param sourcePath Absolute path to the agent YAML file or directory
+   * @param metadata Agent metadata (description, author, tags, main config file)
+   * @param injectPreferences Whether to inject global preferences into agent config (default: true)
+   * @returns Promise resolving to the path of the installed main config file
+   *
+   * @throws {AgentError} When name conflicts with existing agent or installation fails
+   *
+   * @example
+   * ```typescript
+   * await Dexto.installCustomAgent('my-coding-agent', '/path/to/agent.yml', {
+   *   description: 'Custom coding assistant',
+   *   author: 'John Doe',
+   *   tags: ['coding', 'custom']
+   * });
+   * console.log('Custom agent installed successfully');
+   * ```
+   */
+  static async installCustomAgent(agentName, sourcePath, metadata, injectPreferences = true) {
+    const agentRegistry = getAgentRegistry();
+    try {
+      const mainConfigPath = await agentRegistry.installCustomAgentFromPath(
+        agentName,
+        sourcePath,
+        metadata,
+        injectPreferences
+      );
+      logger.info(`Successfully installed custom agent: ${agentName}`);
+      return mainConfigPath;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to install custom agent ${agentName}: ${errorMessage}`);
+      throw AgentError.apiValidationError(
+        `Installation failed for custom agent '${agentName}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Uninstalls an agent by removing its directory from disk.
+   * For custom agents: also removes from user registry.
+   * For builtin agents: only removes from disk (can be reinstalled).
+   *
+   * @param agentName The name of the agent to uninstall
+   * @param force Whether to force uninstall even if agent is protected (default: false)
+   * @returns Promise that resolves when uninstallation is complete
+   *
+   * @throws {AgentError} When agent is not installed or uninstallation fails
+   *
+   * @example
+   * ```typescript
+   * await Dexto.uninstallAgent('my-custom-agent');
+   * console.log('Agent uninstalled successfully');
+   * ```
+   */
+  static async uninstallAgent(agentName, force = false) {
+    const agentRegistry = getAgentRegistry();
+    try {
+      await agentRegistry.uninstallAgent(agentName, force);
+      logger.info(`Successfully uninstalled agent: ${agentName}`);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`Failed to uninstall agent ${agentName}: ${errorMessage}`);
+      throw AgentError.apiValidationError(
+        `Uninstallation failed for agent '${agentName}'`,
+        error
+      );
+    }
+  }
+  /**
+   * Creates a new agent instance for the specified agent name.
+   * This method resolves the agent (installing if needed), loads its configuration,
+   * and returns a new DextoAgent instance ready to be started.
+   *
+   * This is a factory method that doesn't affect any existing agent instances.
+   * The caller is responsible for managing the lifecycle of the returned agent.
+   *
+   * @param agentName The name of the agent to create
+   * @returns Promise resolving to a new DextoAgent instance (not started)
+   *
+   * @throws {AgentError} When agent is not found or creation fails
+   *
+   * @example
+   * ```typescript
+   * const newAgent = await Dexto.createAgent('productivity');
+   * await newAgent.start();
+   * ```
+   */
+  static async createAgent(agentName) {
+    const agentRegistry = getAgentRegistry();
+    try {
+      const agentPath = await agentRegistry.resolveAgent(agentName, true, true);
+      const config = await loadAgentConfig(agentPath);
+      logger.info(`Creating agent: ${agentName}`);
+      const newAgent = new DextoAgent(config, agentPath);
+      logger.info(`Successfully created agent: ${agentName}`);
+      return newAgent;
+    } catch (error) {
+      logger.error(
+        `Failed to create agent '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw AgentError.apiValidationError(`Failed to create agent '${agentName}'`, error);
+    }
+  }
+}
+export {
+  Dexto
+};