@dexto/core 1.1.4 → 1.1.6

package/dist/config/agent-resolver.cjs

@@ -0,0 +1,153 @@
+"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 agent_resolver_exports = {};
+__export(agent_resolver_exports, {
+  resolveAgentPath: () => resolveAgentPath,
+  updateDefaultAgentPreference: () => updateDefaultAgentPreference
+});
+module.exports = __toCommonJS(agent_resolver_exports);
+var import_fs = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_path2 = require("../utils/path.cjs");
+var import_execution_context = require("../utils/execution-context.cjs");
+var import_loader = require("../preferences/loader.cjs");
+var import_logger = require("../logger/index.cjs");
+var import_errors = require("./errors.js");
+async function resolveAgentPath(nameOrPath, autoInstall = true, injectPreferences = true) {
+  if (nameOrPath && (0, import_path2.isPath)(nameOrPath)) {
+    const resolved = import_path.default.resolve(nameOrPath);
+    try {
+      const stat = await import_fs.promises.stat(resolved);
+      if (!stat.isFile()) {
+        throw import_errors.ConfigError.fileNotFound(resolved);
+      }
+      return resolved;
+    } catch {
+      throw import_errors.ConfigError.fileNotFound(resolved);
+    }
+  }
+  if (nameOrPath) {
+    const { getAgentRegistry } = await import("../agent/registry/registry.cjs");
+    const registry = getAgentRegistry();
+    return await registry.resolveAgent(nameOrPath, autoInstall, injectPreferences);
+  }
+  return await resolveDefaultAgentByContext(autoInstall, injectPreferences);
+}
+async function resolveDefaultAgentByContext(autoInstall = true, injectPreferences = true) {
+  const executionContext = (0, import_execution_context.getExecutionContext)();
+  switch (executionContext) {
+    case "dexto-source":
+      return await resolveDefaultAgentForDextoSource();
+    case "dexto-project":
+      return await resolveDefaultAgentForDextoProject(autoInstall, injectPreferences);
+    case "global-cli":
+      return await resolveDefaultAgentForGlobalCLI(autoInstall, injectPreferences);
+    default:
+      throw import_errors.ConfigError.unknownContext(executionContext);
+  }
+}
+async function resolveDefaultAgentForDextoSource() {
+  import_logger.logger.debug("Resolving default agent for dexto source context");
+  const sourceRoot = (0, import_execution_context.findDextoSourceRoot)();
+  if (!sourceRoot) {
+    throw import_errors.ConfigError.bundledNotFound("dexto source directory not found");
+  }
+  const bundledPath = import_path.default.join(sourceRoot, "agents", "default-agent.yml");
+  try {
+    await import_fs.promises.access(bundledPath);
+    return bundledPath;
+  } catch {
+    throw import_errors.ConfigError.bundledNotFound(bundledPath);
+  }
+}
+async function resolveDefaultAgentForDextoProject(autoInstall = true, injectPreferences = true) {
+  import_logger.logger.debug("Resolving default agent for dexto project context");
+  const projectRoot = (0, import_execution_context.findDextoProjectRoot)();
+  if (!projectRoot) {
+    throw import_errors.ConfigError.unknownContext("dexto-project: project root not found");
+  }
+  const candidatePaths = [
+    import_path.default.join(projectRoot, "default-agent.yml"),
+    import_path.default.join(projectRoot, "agents", "default-agent.yml"),
+    import_path.default.join(projectRoot, "src", "dexto", "agents", "default-agent.yml")
+  ];
+  for (const p of candidatePaths) {
+    try {
+      await import_fs.promises.access(p);
+      return p;
+    } catch {
+    }
+  }
+  import_logger.logger.debug(`No project-local default-agent.yml found in ${projectRoot}`);
+  if (!(0, import_loader.globalPreferencesExist)()) {
+    throw import_errors.ConfigError.noProjectDefault(projectRoot);
+  }
+  const preferences = await (0, import_loader.loadGlobalPreferences)();
+  if (!preferences.setup.completed) {
+    throw import_errors.ConfigError.setupIncomplete();
+  }
+  const preferredAgentName = preferences.defaults.defaultAgent;
+  const { getAgentRegistry } = await import("../agent/registry/registry.cjs");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function resolveDefaultAgentForGlobalCLI(autoInstall = true, injectPreferences = true) {
+  import_logger.logger.debug("Resolving default agent for global CLI context");
+  if (!(0, import_loader.globalPreferencesExist)()) {
+    throw import_errors.ConfigError.noGlobalPreferences();
+  }
+  const preferences = await (0, import_loader.loadGlobalPreferences)();
+  if (!preferences.setup.completed) {
+    throw import_errors.ConfigError.setupIncomplete();
+  }
+  const preferredAgentName = preferences.defaults.defaultAgent;
+  const { getAgentRegistry } = await import("../agent/registry/registry.cjs");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function updateDefaultAgentPreference(agentName) {
+  const { getAgentRegistry } = await import("../agent/registry/registry.cjs");
+  const { RegistryError } = await import("../agent/registry/errors.cjs");
+  const { isPath: isPath2 } = await import("../utils/path.cjs");
+  const registry = getAgentRegistry();
+  if (isPath2(agentName) || !registry.hasAgent(agentName)) {
+    const available = Object.keys(registry.getAvailableAgents());
+    throw RegistryError.agentNotFound(agentName, available);
+  }
+  const { updateGlobalPreferences } = await import("../preferences/loader.cjs");
+  await updateGlobalPreferences({
+    defaults: { defaultAgent: agentName }
+  });
+  import_logger.logger.info(`Updated default agent preference to: ${agentName}`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  resolveAgentPath,
+  updateDefaultAgentPreference
+});

package/dist/config/agent-resolver.d.cts

@@ -0,0 +1,15 @@
+/**
+ * Resolve agent path with preference integration
+ * @param nameOrPath Optional agent name or explicit path
+ * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+ * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+ * @returns Resolved absolute path to agent config
+ * @throws DextoRuntimeError for any resolution failures
+ */
+declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+/**
+ * Update default agent preference
+ */
+declare function updateDefaultAgentPreference(agentName: string): Promise<void>;
+
+export { resolveAgentPath, updateDefaultAgentPreference };

package/dist/config/agent-resolver.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Resolve agent path with preference integration
+ * @param nameOrPath Optional agent name or explicit path
+ * @param autoInstall Whether to automatically install missing agents from registry (default: true)
+ * @param injectPreferences Whether to inject preferences during auto-installation (default: true)
+ * @returns Resolved absolute path to agent config
+ * @throws DextoRuntimeError for any resolution failures
+ */
+declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+/**
+ * Update default agent preference
+ */
+declare function updateDefaultAgentPreference(agentName: string): Promise<void>;
+
+export { resolveAgentPath, updateDefaultAgentPreference };

package/dist/config/agent-resolver.js

@@ -0,0 +1,122 @@
+import { promises as fs } from "fs";
+import path from "path";
+import { isPath } from "../utils/path.js";
+import {
+  getExecutionContext,
+  findDextoSourceRoot,
+  findDextoProjectRoot
+} from "../utils/execution-context.js";
+import { loadGlobalPreferences, globalPreferencesExist } from "../preferences/loader.js";
+import { logger } from "../logger/index.js";
+import { ConfigError } from "./errors.js";
+async function resolveAgentPath(nameOrPath, autoInstall = true, injectPreferences = true) {
+  if (nameOrPath && isPath(nameOrPath)) {
+    const resolved = path.resolve(nameOrPath);
+    try {
+      const stat = await fs.stat(resolved);
+      if (!stat.isFile()) {
+        throw ConfigError.fileNotFound(resolved);
+      }
+      return resolved;
+    } catch {
+      throw ConfigError.fileNotFound(resolved);
+    }
+  }
+  if (nameOrPath) {
+    const { getAgentRegistry } = await import("../agent/registry/registry.js");
+    const registry = getAgentRegistry();
+    return await registry.resolveAgent(nameOrPath, autoInstall, injectPreferences);
+  }
+  return await resolveDefaultAgentByContext(autoInstall, injectPreferences);
+}
+async function resolveDefaultAgentByContext(autoInstall = true, injectPreferences = true) {
+  const executionContext = getExecutionContext();
+  switch (executionContext) {
+    case "dexto-source":
+      return await resolveDefaultAgentForDextoSource();
+    case "dexto-project":
+      return await resolveDefaultAgentForDextoProject(autoInstall, injectPreferences);
+    case "global-cli":
+      return await resolveDefaultAgentForGlobalCLI(autoInstall, injectPreferences);
+    default:
+      throw ConfigError.unknownContext(executionContext);
+  }
+}
+async function resolveDefaultAgentForDextoSource() {
+  logger.debug("Resolving default agent for dexto source context");
+  const sourceRoot = findDextoSourceRoot();
+  if (!sourceRoot) {
+    throw ConfigError.bundledNotFound("dexto source directory not found");
+  }
+  const bundledPath = path.join(sourceRoot, "agents", "default-agent.yml");
+  try {
+    await fs.access(bundledPath);
+    return bundledPath;
+  } catch {
+    throw ConfigError.bundledNotFound(bundledPath);
+  }
+}
+async function resolveDefaultAgentForDextoProject(autoInstall = true, injectPreferences = true) {
+  logger.debug("Resolving default agent for dexto project context");
+  const projectRoot = findDextoProjectRoot();
+  if (!projectRoot) {
+    throw ConfigError.unknownContext("dexto-project: project root not found");
+  }
+  const candidatePaths = [
+    path.join(projectRoot, "default-agent.yml"),
+    path.join(projectRoot, "agents", "default-agent.yml"),
+    path.join(projectRoot, "src", "dexto", "agents", "default-agent.yml")
+  ];
+  for (const p of candidatePaths) {
+    try {
+      await fs.access(p);
+      return p;
+    } catch {
+    }
+  }
+  logger.debug(`No project-local default-agent.yml found in ${projectRoot}`);
+  if (!globalPreferencesExist()) {
+    throw ConfigError.noProjectDefault(projectRoot);
+  }
+  const preferences = await loadGlobalPreferences();
+  if (!preferences.setup.completed) {
+    throw ConfigError.setupIncomplete();
+  }
+  const preferredAgentName = preferences.defaults.defaultAgent;
+  const { getAgentRegistry } = await import("../agent/registry/registry.js");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function resolveDefaultAgentForGlobalCLI(autoInstall = true, injectPreferences = true) {
+  logger.debug("Resolving default agent for global CLI context");
+  if (!globalPreferencesExist()) {
+    throw ConfigError.noGlobalPreferences();
+  }
+  const preferences = await loadGlobalPreferences();
+  if (!preferences.setup.completed) {
+    throw ConfigError.setupIncomplete();
+  }
+  const preferredAgentName = preferences.defaults.defaultAgent;
+  const { getAgentRegistry } = await import("../agent/registry/registry.js");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function updateDefaultAgentPreference(agentName) {
+  const { getAgentRegistry } = await import("../agent/registry/registry.js");
+  const { RegistryError } = await import("../agent/registry/errors.js");
+  const { isPath: isPath2 } = await import("../utils/path.js");
+  const registry = getAgentRegistry();
+  if (isPath2(agentName) || !registry.hasAgent(agentName)) {
+    const available = Object.keys(registry.getAvailableAgents());
+    throw RegistryError.agentNotFound(agentName, available);
+  }
+  const { updateGlobalPreferences } = await import("../preferences/loader.js");
+  await updateGlobalPreferences({
+    defaults: { defaultAgent: agentName }
+  });
+  logger.info(`Updated default agent preference to: ${agentName}`);
+}
+export {
+  resolveAgentPath,
+  updateDefaultAgentPreference
+};

package/dist/config/error-codes.cjs

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_codes_exports = {};
+__export(error_codes_exports, {
+  ConfigErrorCode: () => ConfigErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var ConfigErrorCode = /* @__PURE__ */ ((ConfigErrorCode2) => {
+  ConfigErrorCode2["FILE_NOT_FOUND"] = "config_file_not_found";
+  ConfigErrorCode2["FILE_READ_ERROR"] = "config_file_read_error";
+  ConfigErrorCode2["FILE_WRITE_ERROR"] = "config_file_write_error";
+  ConfigErrorCode2["PARSE_ERROR"] = "config_parse_error";
+  ConfigErrorCode2["NO_PROJECT_DEFAULT"] = "config_no_project_default";
+  ConfigErrorCode2["NO_GLOBAL_PREFERENCES"] = "config_no_global_preferences";
+  ConfigErrorCode2["SETUP_INCOMPLETE"] = "config_setup_incomplete";
+  ConfigErrorCode2["BUNDLED_NOT_FOUND"] = "config_bundled_not_found";
+  ConfigErrorCode2["UNKNOWN_CONTEXT"] = "config_unknown_context";
+  return ConfigErrorCode2;
+})(ConfigErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigErrorCode
+});

package/dist/config/error-codes.d.cts

@@ -0,0 +1,17 @@
+/**
+ * Config-specific error codes
+ * Includes file operations, parsing, and validation errors for configuration management
+ */
+declare enum ConfigErrorCode {
+    FILE_NOT_FOUND = "config_file_not_found",
+    FILE_READ_ERROR = "config_file_read_error",
+    FILE_WRITE_ERROR = "config_file_write_error",
+    PARSE_ERROR = "config_parse_error",
+    NO_PROJECT_DEFAULT = "config_no_project_default",
+    NO_GLOBAL_PREFERENCES = "config_no_global_preferences",
+    SETUP_INCOMPLETE = "config_setup_incomplete",
+    BUNDLED_NOT_FOUND = "config_bundled_not_found",
+    UNKNOWN_CONTEXT = "config_unknown_context"
+}
+
+export { ConfigErrorCode };

package/dist/config/error-codes.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Config-specific error codes
+ * Includes file operations, parsing, and validation errors for configuration management
+ */
+declare enum ConfigErrorCode {
+    FILE_NOT_FOUND = "config_file_not_found",
+    FILE_READ_ERROR = "config_file_read_error",
+    FILE_WRITE_ERROR = "config_file_write_error",
+    PARSE_ERROR = "config_parse_error",
+    NO_PROJECT_DEFAULT = "config_no_project_default",
+    NO_GLOBAL_PREFERENCES = "config_no_global_preferences",
+    SETUP_INCOMPLETE = "config_setup_incomplete",
+    BUNDLED_NOT_FOUND = "config_bundled_not_found",
+    UNKNOWN_CONTEXT = "config_unknown_context"
+}
+
+export { ConfigErrorCode };

package/dist/config/error-codes.js

@@ -0,0 +1,15 @@
+var ConfigErrorCode = /* @__PURE__ */ ((ConfigErrorCode2) => {
+  ConfigErrorCode2["FILE_NOT_FOUND"] = "config_file_not_found";
+  ConfigErrorCode2["FILE_READ_ERROR"] = "config_file_read_error";
+  ConfigErrorCode2["FILE_WRITE_ERROR"] = "config_file_write_error";
+  ConfigErrorCode2["PARSE_ERROR"] = "config_parse_error";
+  ConfigErrorCode2["NO_PROJECT_DEFAULT"] = "config_no_project_default";
+  ConfigErrorCode2["NO_GLOBAL_PREFERENCES"] = "config_no_global_preferences";
+  ConfigErrorCode2["SETUP_INCOMPLETE"] = "config_setup_incomplete";
+  ConfigErrorCode2["BUNDLED_NOT_FOUND"] = "config_bundled_not_found";
+  ConfigErrorCode2["UNKNOWN_CONTEXT"] = "config_unknown_context";
+  return ConfigErrorCode2;
+})(ConfigErrorCode || {});
+export {
+  ConfigErrorCode
+};

package/dist/config/errors.cjs

@@ -0,0 +1,126 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var errors_exports = {};
+__export(errors_exports, {
+  ConfigError: () => ConfigError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_errors = require("../errors/index.js");
+var import_types = require("../errors/types.js");
+var import_error_codes = require("./error-codes.js");
+class ConfigError {
+  // File operation errors
+  static fileNotFound(configPath) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.FILE_NOT_FOUND,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.USER,
+      `Configuration file not found: ${configPath}`,
+      { configPath },
+      "Ensure the configuration file exists at the specified path"
+    );
+  }
+  static fileReadError(configPath, cause) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.FILE_READ_ERROR,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.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 import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.FILE_WRITE_ERROR,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.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 import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.PARSE_ERROR,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.USER,
+      `Failed to parse configuration file: ${cause}`,
+      { configPath, cause },
+      "Ensure the configuration file contains valid YAML syntax"
+    );
+  }
+  // Resolution errors
+  static noProjectDefault(projectPath) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.NO_PROJECT_DEFAULT,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.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 import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.NO_GLOBAL_PREFERENCES,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.USER,
+      `No global preferences found. Run \`dexto setup\` to get started.`,
+      {},
+      "Run `dexto setup` to configure your AI preferences"
+    );
+  }
+  static setupIncomplete() {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.SETUP_INCOMPLETE,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.USER,
+      `Global preferences setup is incomplete. Run \`dexto setup\` to complete.`,
+      {},
+      "Run `dexto setup` to complete your configuration"
+    );
+  }
+  static bundledNotFound(bundledPath) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.BUNDLED_NOT_FOUND,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.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 import_errors.DextoRuntimeError(
+      import_error_codes.ConfigErrorCode.UNKNOWN_CONTEXT,
+      import_types.ErrorScope.CONFIG,
+      import_types.ErrorType.SYSTEM,
+      `Unknown execution context: ${context}`,
+      { context },
+      "This is an internal error - please report it"
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigError
+});

package/dist/config/errors.d.cts

@@ -0,0 +1,49 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.cjs';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import './error-codes.cjs';
+import '../context/error-codes.cjs';
+import '../llm/error-codes.cjs';
+import '../mcp/error-codes.cjs';
+import '../session/error-codes.cjs';
+import '../storage/error-codes.cjs';
+import '../systemPrompt/error-codes.cjs';
+import '../tools/error-codes.cjs';
+import '../preferences/error-codes.cjs';
+import '../agent/registry/error-codes.cjs';
+
+/**
+ * Config runtime error factory methods
+ * Creates properly typed errors for configuration operations
+ */
+declare class ConfigError {
+    static fileNotFound(configPath: string): DextoRuntimeError<{
+        configPath: string;
+    }>;
+    static fileReadError(configPath: string, cause: string): DextoRuntimeError<{
+        configPath: string;
+        cause: string;
+    }>;
+    static fileWriteError(configPath: string, cause: string): DextoRuntimeError<{
+        configPath: string;
+        cause: string;
+    }>;
+    static parseError(configPath: string, cause: string): DextoRuntimeError<{
+        configPath: string;
+        cause: string;
+    }>;
+    static noProjectDefault(projectPath: string): DextoRuntimeError<{
+        projectPath: string;
+    }>;
+    static noGlobalPreferences(): DextoRuntimeError<{}>;
+    static setupIncomplete(): DextoRuntimeError<{}>;
+    static bundledNotFound(bundledPath: string): DextoRuntimeError<{
+        path: string;
+    }>;
+    static unknownContext(context: string): DextoRuntimeError<{
+        context: string;
+    }>;
+}
+
+export { ConfigError };

package/dist/config/errors.d.ts

@@ -0,0 +1,49 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import './error-codes.js';
+import '../context/error-codes.js';
+import '../llm/error-codes.js';
+import '../mcp/error-codes.js';
+import '../session/error-codes.js';
+import '../storage/error-codes.js';
+import '../systemPrompt/error-codes.js';
+import '../tools/error-codes.js';
+import '../preferences/error-codes.js';
+import '../agent/registry/error-codes.js';
+
+/**
+ * Config runtime error factory methods
+ * Creates properly typed errors for configuration operations
+ */
+declare class ConfigError {
+    static fileNotFound(configPath: string): DextoRuntimeError<{
+        configPath: string;
+    }>;
+    static fileReadError(configPath: string, cause: string): DextoRuntimeError<{
+        configPath: string;
+        cause: string;
+    }>;
+    static fileWriteError(configPath: string, cause: string): DextoRuntimeError<{
+        configPath: string;
+        cause: string;
+    }>;
+    static parseError(configPath: string, cause: string): DextoRuntimeError<{
+        configPath: string;
+        cause: string;
+    }>;
+    static noProjectDefault(projectPath: string): DextoRuntimeError<{
+        projectPath: string;
+    }>;
+    static noGlobalPreferences(): DextoRuntimeError<{}>;
+    static setupIncomplete(): DextoRuntimeError<{}>;
+    static bundledNotFound(bundledPath: string): DextoRuntimeError<{
+        path: string;
+    }>;
+    static unknownContext(context: string): DextoRuntimeError<{
+        context: string;
+    }>;
+}
+
+export { ConfigError };