@dexto/core 1.1.4

package/dist/chunk-F2QFAECT.js

@@ -0,0 +1,87 @@
+import {
+  DextoRuntimeError
+} from "./chunk-TPERKLLN.js";
+import {
+  init_esm_shims
+} from "./chunk-MVKLS3LM.js";
+
+// src/storage/errors.ts
+init_esm_shims();
+var StorageError = class {
+  /**
+   * Connection failed error
+   */
+  static connectionFailed(reason, config) {
+    return new DextoRuntimeError(
+      "storage_connection_failed" /* CONNECTION_FAILED */,
+      "storage" /* STORAGE */,
+      "third_party" /* THIRD_PARTY */,
+      `Storage connection failed: ${reason}`,
+      { reason, config }
+    );
+  }
+  /**
+   * Backend not connected error
+   */
+  static notConnected(backendType) {
+    return new DextoRuntimeError(
+      "storage_connection_failed" /* CONNECTION_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `${backendType} not connected`,
+      { backendType }
+    );
+  }
+  /**
+   * Read operation failed
+   */
+  static readFailed(operation, reason, details) {
+    return new DextoRuntimeError(
+      "storage_read_failed" /* READ_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Storage read failed for ${operation}: ${reason}`,
+      { operation, reason, ...details }
+    );
+  }
+  /**
+   * Write operation failed
+   */
+  static writeFailed(operation, reason, details) {
+    return new DextoRuntimeError(
+      "storage_write_failed" /* WRITE_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Storage write failed for ${operation}: ${reason}`,
+      { operation, reason, ...details }
+    );
+  }
+  /**
+   * Delete operation failed
+   */
+  static deleteFailed(operation, reason, details) {
+    return new DextoRuntimeError(
+      "storage_delete_failed" /* DELETE_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Storage delete failed for ${operation}: ${reason}`,
+      { operation, reason, ...details }
+    );
+  }
+  /**
+   * Migration failed error
+   */
+  static migrationFailed(reason, details) {
+    return new DextoRuntimeError(
+      "storage_migration_failed" /* MIGRATION_FAILED */,
+      "storage" /* STORAGE */,
+      "system" /* SYSTEM */,
+      `Database migration failed: ${reason}`,
+      { reason, ...details }
+    );
+  }
+};
+
+export {
+  StorageError
+};

package/dist/chunk-FCJVTIBV.js

@@ -0,0 +1,535 @@
+import {
+  loadGlobalPreferences
+} from "./chunk-J6AXCN3H.js";
+import {
+  RegistryError
+} from "./chunk-PI6XFMEW.js";
+import {
+  copyDirectory,
+  getDextoGlobalPath,
+  logger,
+  resolveBundledScript
+} from "./chunk-D62MHQBE.js";
+import {
+  DextoRuntimeError
+} from "./chunk-TPERKLLN.js";
+import {
+  init_esm_shims
+} from "./chunk-MVKLS3LM.js";
+
+// src/agent/registry/registry.ts
+init_esm_shims();
+import { existsSync, readFileSync } from "fs";
+import { promises as fs2 } from "fs";
+import path2 from "path";
+
+// src/config/writer.ts
+init_esm_shims();
+import { promises as fs } from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import * as path from "path";
+
+// src/config/errors.ts
+init_esm_shims();
+var ConfigError = class {
+  // File operation errors
+  static fileNotFound(configPath) {
+    return new DextoRuntimeError(
+      "config_file_not_found" /* FILE_NOT_FOUND */,
+      "config" /* CONFIG */,
+      "user" /* USER */,
+      `Configuration file not found: ${configPath}`,
+      { configPath },
+      "Ensure the configuration file exists at the specified path"
+    );
+  }
+  static fileReadError(configPath, cause) {
+    return new DextoRuntimeError(
+      "config_file_read_error" /* FILE_READ_ERROR */,
+      "config" /* CONFIG */,
+      "system" /* SYSTEM */,
+      `Failed to read configuration file: ${cause}`,
+      { configPath, cause },
+      "Check file permissions and ensure the file is not corrupted"
+    );
+  }
+  static fileWriteError(configPath, cause) {
+    return new DextoRuntimeError(
+      "config_file_write_error" /* FILE_WRITE_ERROR */,
+      "config" /* CONFIG */,
+      "system" /* SYSTEM */,
+      `Failed to write configuration file '${configPath}': ${cause}`,
+      { configPath, cause },
+      "Check file permissions and available disk space"
+    );
+  }
+  // Parsing errors
+  static parseError(configPath, cause) {
+    return new DextoRuntimeError(
+      "config_parse_error" /* PARSE_ERROR */,
+      "config" /* CONFIG */,
+      "user" /* USER */,
+      `Failed to parse configuration file: ${cause}`,
+      { configPath, cause },
+      "Ensure the configuration file contains valid YAML syntax"
+    );
+  }
+  // Resolution errors
+  static noProjectDefault(projectPath) {
+    return new DextoRuntimeError(
+      "config_no_project_default" /* NO_PROJECT_DEFAULT */,
+      "config" /* CONFIG */,
+      "user" /* USER */,
+      `No project default-agent.yml found and no global preferences configured.
+Either create default-agent.yml in your project root (${projectPath}) or run \`dexto setup\` to configure preferences.`,
+      { projectPath },
+      "Run `dexto setup` or create a project-specific agent config"
+    );
+  }
+  static noGlobalPreferences() {
+    return new DextoRuntimeError(
+      "config_no_global_preferences" /* NO_GLOBAL_PREFERENCES */,
+      "config" /* CONFIG */,
+      "user" /* USER */,
+      `No global preferences found. Run \`dexto setup\` to get started.`,
+      {},
+      "Run `dexto setup` to configure your AI preferences"
+    );
+  }
+  static setupIncomplete() {
+    return new DextoRuntimeError(
+      "config_setup_incomplete" /* SETUP_INCOMPLETE */,
+      "config" /* CONFIG */,
+      "user" /* USER */,
+      `Global preferences setup is incomplete. Run \`dexto setup\` to complete.`,
+      {},
+      "Run `dexto setup` to complete your configuration"
+    );
+  }
+  static bundledNotFound(bundledPath) {
+    return new DextoRuntimeError(
+      "config_bundled_not_found" /* BUNDLED_NOT_FOUND */,
+      "config" /* CONFIG */,
+      "not_found" /* NOT_FOUND */,
+      `Bundled default agent not found: ${bundledPath}. Run npm run build first.`,
+      { path: bundledPath },
+      "Run `npm run build` to build the bundled agents"
+    );
+  }
+  static unknownContext(context) {
+    return new DextoRuntimeError(
+      "config_unknown_context" /* UNKNOWN_CONTEXT */,
+      "config" /* CONFIG */,
+      "system" /* SYSTEM */,
+      `Unknown execution context: ${context}`,
+      { context },
+      "This is an internal error - please report it"
+    );
+  }
+};
+
+// src/config/writer.ts
+async function writeConfigFile(configPath, config) {
+  const absolutePath = path.resolve(configPath);
+  try {
+    const yamlContent = stringifyYaml(config, { indent: 2 });
+    await fs.writeFile(absolutePath, yamlContent, "utf-8");
+    logger.debug(`Wrote dexto config to: ${absolutePath}`);
+  } catch (error) {
+    throw ConfigError.fileWriteError(
+      absolutePath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function writeLLMPreferences(configPath, preferences, overrides) {
+  logger.debug(`Writing LLM preferences to: ${configPath}`, {
+    provider: overrides?.provider ?? preferences.llm.provider,
+    model: overrides?.model ?? preferences.llm.model,
+    hasApiKeyOverride: Boolean(overrides?.apiKey),
+    hasPreferenceApiKey: Boolean(preferences.llm.apiKey)
+  });
+  logger.debug(`Reading config file: ${configPath}`);
+  let fileContent;
+  try {
+    fileContent = await fs.readFile(configPath, "utf-8");
+    logger.debug(`Successfully read config file (${fileContent.length} chars)`);
+  } catch (error) {
+    logger.error(`Failed to read config file: ${configPath}`, { error });
+    throw ConfigError.fileReadError(
+      configPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  let config;
+  try {
+    config = parseYaml(fileContent);
+    logger.debug(`Successfully parsed YAML config`, {
+      hasLlmSection: Boolean(config.llm),
+      existingProvider: config.llm?.provider,
+      existingModel: config.llm?.model
+    });
+  } catch (error) {
+    logger.error(`Failed to parse YAML config: ${configPath}`, { error });
+    throw ConfigError.parseError(
+      configPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const provider = overrides?.provider ?? preferences.llm.provider;
+  const model = overrides?.model ?? preferences.llm.model;
+  const apiKey = overrides?.apiKey ?? preferences.llm.apiKey;
+  logger.debug(`Applying LLM preferences`, {
+    finalProvider: provider,
+    finalModel: model,
+    hasApiKey: Boolean(apiKey),
+    source: overrides ? "CLI overrides + preferences" : "preferences only"
+  });
+  config.llm = {
+    ...config.llm,
+    // Preserve temperature, router, maxTokens, etc.
+    provider,
+    // Write user preference
+    model,
+    // Write user preference
+    apiKey
+    // Write user preference
+  };
+  await writeConfigFile(configPath, config);
+  logger.info(`\u2713 Applied preferences to: ${path.basename(configPath)} (${provider}/${model})`);
+}
+async function writePreferencesToAgent(installedPath, preferences, overrides) {
+  let stat;
+  try {
+    stat = await fs.stat(installedPath);
+  } catch (error) {
+    throw ConfigError.fileReadError(
+      installedPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  if (stat.isFile()) {
+    if (installedPath.endsWith(".yml") || installedPath.endsWith(".yaml")) {
+      await writeLLMPreferences(installedPath, preferences, overrides);
+      logger.info(`\u2713 Applied preferences to: ${path.basename(installedPath)}`, null, "green");
+    } else {
+      logger.warn(`Skipping non-YAML file: ${installedPath}`, null, "yellow");
+    }
+  } else if (stat.isDirectory()) {
+    await writePreferencesToDirectory(installedPath, preferences, overrides);
+  } else {
+    throw ConfigError.fileReadError(installedPath, "Path is neither a file nor directory");
+  }
+}
+async function writePreferencesToDirectory(installedDir, preferences, overrides) {
+  const configFiles = await findAgentConfigFiles(installedDir);
+  if (configFiles.length === 0) {
+    logger.warn(`No YAML config files found in: ${installedDir}`);
+    return;
+  }
+  let successCount = 0;
+  const oldProvider = preferences.llm.provider;
+  const oldModel = preferences.llm.model;
+  const newProvider = overrides?.provider ?? preferences.llm.provider;
+  const newModel = overrides?.model ?? preferences.llm.model;
+  for (const configPath of configFiles) {
+    try {
+      await writeLLMPreferences(configPath, preferences, overrides);
+      logger.debug(`Applied preferences to: ${path.relative(installedDir, configPath)}`);
+      successCount++;
+    } catch (error) {
+      logger.warn(
+        `Failed to write preferences to ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  logger.info(
+    `\u2713 Applied preferences to ${successCount}/${configFiles.length} config files (${oldProvider}\u2192${newProvider}, ${oldModel}\u2192${newModel})`
+  );
+}
+async function findAgentConfigFiles(dir) {
+  const configFiles = [];
+  async function walkDir(currentDir) {
+    const entries = await fs.readdir(currentDir, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(currentDir, entry.name);
+      if (entry.isDirectory()) {
+        if (!["docs", "data"].includes(entry.name)) {
+          await walkDir(fullPath);
+        }
+      } else if (entry.name.endsWith(".yml") || entry.name.endsWith(".yaml")) {
+        configFiles.push(fullPath);
+      }
+    }
+  }
+  await walkDir(dir);
+  return configFiles;
+}
+
+// src/agent/registry/types.ts
+init_esm_shims();
+import { z } from "zod";
+var AgentRegistryEntrySchema = z.object({
+  description: z.string(),
+  author: z.string(),
+  tags: z.array(z.string()),
+  source: z.string(),
+  main: z.string().optional()
+}).strict();
+var RegistrySchema = z.object({
+  version: z.string(),
+  agents: z.record(z.string(), AgentRegistryEntrySchema)
+}).strict();
+
+// src/agent/registry/registry.ts
+var cachedRegistry = null;
+var LocalAgentRegistry = class {
+  _registry = null;
+  /**
+   * Lazy load registry from JSON file
+   */
+  getRegistry() {
+    if (this._registry === null) {
+      this._registry = this.loadRegistry();
+    }
+    return this._registry;
+  }
+  /**
+   * Load registry from bundled JSON file
+   * Uses fail-fast approach - throws RegistryError for any loading issues
+   */
+  loadRegistry() {
+    let jsonPath;
+    try {
+      jsonPath = resolveBundledScript("agents/agent-registry.json");
+    } catch (_error) {
+      throw RegistryError.registryNotFound(
+        "agents/agent-registry.json (bundle resolution failed)"
+      );
+    }
+    if (!existsSync(jsonPath)) {
+      throw RegistryError.registryNotFound(jsonPath);
+    }
+    try {
+      const jsonData = readFileSync(jsonPath, "utf-8");
+      const rawRegistry = JSON.parse(jsonData);
+      return RegistrySchema.parse(rawRegistry);
+    } catch (error) {
+      throw RegistryError.registryParseError(
+        jsonPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Check if agent exists in registry
+   */
+  hasAgent(name) {
+    const registry = this.getRegistry();
+    return name in registry.agents;
+  }
+  /**
+   * Get available agents with their metadata from registry
+   */
+  getAvailableAgents() {
+    const registry = this.getRegistry();
+    return registry.agents;
+  }
+  /**
+   * Resolve main config file for installed agent
+   * Handles both directory agents (with main field) and single-file agents
+   */
+  resolveMainConfig(agentDir, agentName) {
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentName, available);
+    }
+    if (agentData.source.endsWith("/")) {
+      if (!agentData.main) {
+        throw RegistryError.agentInvalidEntry(
+          agentName,
+          "directory entry missing main field"
+        );
+      }
+      const mainConfigPath = path2.join(agentDir, agentData.main);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.mainConfigMissing(agentName, mainConfigPath);
+      }
+      return mainConfigPath;
+    } else {
+      const filename = path2.basename(agentData.source);
+      const configPath = path2.join(agentDir, filename);
+      if (!existsSync(configPath)) {
+        throw RegistryError.configNotFound(configPath);
+      }
+      return configPath;
+    }
+  }
+  /**
+   * Install agent atomically using temp + rename pattern
+   * @param agentName Name of the agent to install
+   * @param injectPreferences Whether to inject global preferences into installed agent (default: true)
+   */
+  async installAgent(agentName, injectPreferences = true) {
+    logger.info(`Installing agent: ${agentName}`);
+    const registry = this.getRegistry();
+    const agentData = registry.agents[agentName];
+    if (!agentData) {
+      const available = Object.keys(registry.agents);
+      throw RegistryError.agentNotFound(agentName, available);
+    }
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const targetDir = path2.join(globalAgentsDir, agentName);
+    if (existsSync(targetDir)) {
+      logger.info(`Agent '${agentName}' already installed`);
+      return this.resolveMainConfig(targetDir, agentName);
+    }
+    await fs2.mkdir(globalAgentsDir, { recursive: true });
+    const sourcePath = resolveBundledScript(`agents/${agentData.source}`);
+    const tempDir = `${targetDir}.tmp.${Date.now()}`;
+    try {
+      if (agentData.source.endsWith("/")) {
+        await copyDirectory(sourcePath, tempDir);
+      } else {
+        await fs2.mkdir(tempDir, { recursive: true });
+        const targetFile = path2.join(tempDir, path2.basename(sourcePath));
+        await fs2.copyFile(sourcePath, targetFile);
+      }
+      const mainConfigPath = this.resolveMainConfig(tempDir, agentName);
+      if (!existsSync(mainConfigPath)) {
+        throw RegistryError.installationValidationFailed(agentName, mainConfigPath);
+      }
+      await fs2.rename(tempDir, targetDir);
+      logger.info(`\u2713 Installed agent '${agentName}' to ${targetDir}`);
+      if (injectPreferences) {
+        try {
+          const preferences = await loadGlobalPreferences();
+          await writePreferencesToAgent(targetDir, preferences);
+          logger.info(`\u2713 Applied global preferences to installed agent '${agentName}'`);
+        } catch (error) {
+          logger.warn(
+            `Failed to inject preferences to '${agentName}': ${error instanceof Error ? error.message : String(error)}`
+          );
+          console.log(
+            `\u26A0\uFE0F  Warning: Could not apply preferences to '${agentName}' - agent will use bundled settings`
+          );
+        }
+      } else {
+        logger.info(
+          `Skipped preference injection for '${agentName}' (injectPreferences=false)`
+        );
+      }
+      return this.resolveMainConfig(targetDir, agentName);
+    } catch (error) {
+      try {
+        if (existsSync(tempDir)) {
+          await fs2.rm(tempDir, { recursive: true, force: true });
+        }
+      } catch (cleanupError) {
+        logger.error(
+          `Failed to clean up temp directory: ${cleanupError}. Skipping cleanup...`
+        );
+      }
+      throw RegistryError.installationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  /**
+   * Resolve a registry agent name to a config path
+   * NOTE: Only handles registry names, not file paths (routing done in loadAgentConfig)
+   * Handles installing agent if needed
+   * @param agentName Name 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(agentName, autoInstall = true, injectPreferences = true) {
+    logger.debug(`Resolving registry agent: ${agentName}`);
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const installedPath = path2.join(globalAgentsDir, agentName);
+    if (existsSync(installedPath)) {
+      const mainConfig = this.resolveMainConfig(installedPath, agentName);
+      logger.debug(`Resolved installed agent '${agentName}' to: ${mainConfig}`);
+      return mainConfig;
+    }
+    logger.debug(`Agent '${agentName}' not found in installed path: ${installedPath}`);
+    if (this.hasAgent(agentName)) {
+      if (autoInstall) {
+        logger.info(`Installing agent '${agentName}' from registry...`);
+        return await this.installAgent(agentName, injectPreferences);
+      } else {
+        const registry2 = this.getRegistry();
+        const available2 = Object.keys(registry2.agents);
+        throw RegistryError.agentNotInstalledAutoInstallDisabled(agentName, available2);
+      }
+    }
+    const registry = this.getRegistry();
+    const available = Object.keys(registry.agents);
+    throw RegistryError.agentNotFound(agentName, available);
+  }
+  /**
+   * Get list of currently installed agents
+   */
+  async getInstalledAgents() {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    if (!existsSync(globalAgentsDir)) {
+      return [];
+    }
+    try {
+      const entries = await fs2.readdir(globalAgentsDir, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => !name.startsWith(".tmp") && !name.includes(".tmp."));
+    } catch (error) {
+      logger.error(`Failed to read installed agents directory: ${error}`);
+      return [];
+    }
+  }
+  /**
+   * Check if an agent is safe to uninstall (not the default-agent which is critical)
+   */
+  isAgentSafeToUninstall(agentName) {
+    return agentName !== "default-agent";
+  }
+  /**
+   * Uninstall an agent by removing its directory
+   * @param agentName Name of the agent to uninstall
+   * @param force Whether to force uninstall even if agent is protected (default: false)
+   */
+  async uninstallAgent(agentName, force = false) {
+    const globalAgentsDir = getDextoGlobalPath("agents");
+    const agentDir = path2.join(globalAgentsDir, agentName);
+    logger.info(`Uninstalling agent: ${agentName} from ${agentDir}`);
+    if (!existsSync(agentDir)) {
+      throw RegistryError.agentNotInstalled(agentName);
+    }
+    if (!force && !this.isAgentSafeToUninstall(agentName)) {
+      throw RegistryError.agentProtected(agentName);
+    }
+    try {
+      await fs2.rm(agentDir, { recursive: true, force: true });
+      logger.info(`\u2713 Removed agent '${agentName}' from ${agentDir}`);
+    } catch (error) {
+      throw RegistryError.uninstallationFailed(
+        agentName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+};
+function getAgentRegistry() {
+  if (cachedRegistry === null) {
+    cachedRegistry = new LocalAgentRegistry();
+  }
+  return cachedRegistry;
+}
+
+export {
+  ConfigError,
+  writeConfigFile,
+  writeLLMPreferences,
+  writePreferencesToAgent,
+  LocalAgentRegistry,
+  getAgentRegistry
+};