@dexto/agent-management 1.2.5

package/dist/registry/types.js

@@ -0,0 +1,47 @@
+import { z } from "zod";
+function deriveDisplayName(slug) {
+  return slug.split("-").filter(Boolean).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join(" ");
+}
+const AgentRegistryEntrySchema = z.object({
+  id: z.string().describe("Unique identifier for the agent"),
+  name: z.string().describe("Display name for the agent"),
+  description: z.string(),
+  author: z.string(),
+  tags: z.array(z.string()),
+  source: z.string(),
+  main: z.string().optional(),
+  type: z.enum(["builtin", "custom"]).default("builtin").describe("Agent type")
+}).strict();
+const RegistrySchema = z.object({
+  version: z.string(),
+  agents: z.record(z.string(), AgentRegistryEntrySchema)
+}).strict();
+function normalizeRegistryJson(raw) {
+  if (!raw || typeof raw !== "object") {
+    return { version: "1.0.0", agents: {} };
+  }
+  const input = raw;
+  const normalizedAgents = {};
+  const agents = input.agents && typeof input.agents === "object" && input.agents !== null ? input.agents : {};
+  for (const [agentId, value] of Object.entries(agents)) {
+    if (!value || typeof value !== "object") continue;
+    const entry = { ...value };
+    if (!entry.id || typeof entry.id !== "string" || entry.id.trim() !== agentId) {
+      entry.id = agentId;
+    }
+    if (!entry.name || typeof entry.name !== "string" || !entry.name.trim()) {
+      entry.name = deriveDisplayName(agentId);
+    }
+    normalizedAgents[agentId] = entry;
+  }
+  return {
+    version: typeof input.version === "string" && input.version.trim().length > 0 ? input.version : "1.0.0",
+    agents: normalizedAgents
+  };
+}
+export {
+  AgentRegistryEntrySchema,
+  RegistrySchema,
+  deriveDisplayName,
+  normalizeRegistryJson
+};

package/dist/registry/user-registry.cjs

@@ -0,0 +1,140 @@
+"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 user_registry_exports = {};
+__export(user_registry_exports, {
+  addAgentToUserRegistry: () => addAgentToUserRegistry,
+  getUserRegistryPath: () => getUserRegistryPath,
+  loadUserRegistry: () => loadUserRegistry,
+  mergeRegistries: () => mergeRegistries,
+  removeAgentFromUserRegistry: () => removeAgentFromUserRegistry,
+  saveUserRegistry: () => saveUserRegistry,
+  userRegistryHasAgent: () => userRegistryHasAgent
+});
+module.exports = __toCommonJS(user_registry_exports);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_path2 = require("../utils/path.js");
+var import_types = require("./types.js");
+var import_errors = require("./errors.js");
+var import_core = require("@dexto/core");
+const USER_REGISTRY_FILENAME = "user-agent-registry.json";
+function getUserRegistryPath() {
+  return (0, import_path2.getDextoGlobalPath)("", USER_REGISTRY_FILENAME);
+}
+function loadUserRegistry() {
+  const registryPath = getUserRegistryPath();
+  if (!(0, import_fs2.existsSync)(registryPath)) {
+    import_core.logger.debug("User registry not found, returning empty registry");
+    return { version: "1.0.0", agents: {} };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(registryPath, "utf-8");
+    const data = JSON.parse(content);
+    return import_types.RegistrySchema.parse((0, import_types.normalizeRegistryJson)(data));
+  } catch (error) {
+    throw import_errors.RegistryError.registryParseError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveUserRegistry(registry) {
+  const registryPath = getUserRegistryPath();
+  const tempPath = `${registryPath}.tmp.${Date.now()}`;
+  const dextoDir = import_path.default.dirname(registryPath);
+  try {
+    await import_fs.promises.mkdir(dextoDir, { recursive: true });
+    await import_fs.promises.writeFile(tempPath, JSON.stringify(registry, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await import_fs.promises.rename(tempPath, registryPath);
+    import_core.logger.debug(`Saved user registry to ${registryPath}`);
+  } catch (error) {
+    try {
+      if ((0, import_fs2.existsSync)(tempPath)) {
+        await import_fs.promises.rm(tempPath, { force: true });
+      }
+    } catch {
+    }
+    throw import_errors.RegistryError.registryWriteError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function mergeRegistries(bundled, user) {
+  return {
+    version: bundled.version,
+    agents: {
+      ...bundled.agents,
+      ...user.agents
+    }
+  };
+}
+function userRegistryHasAgent(agentId) {
+  const userRegistry = loadUserRegistry();
+  return agentId in userRegistry.agents;
+}
+async function addAgentToUserRegistry(agentId, entry) {
+  const userRegistry = loadUserRegistry();
+  if (agentId in userRegistry.agents) {
+    throw import_errors.RegistryError.agentAlreadyExists(agentId);
+  }
+  userRegistry.agents[agentId] = {
+    ...entry,
+    id: agentId,
+    // Force consistency between key and id field
+    name: entry.name && entry.name.trim().length > 0 ? entry.name : (0, import_types.deriveDisplayName)(agentId),
+    // Ensure name is never undefined or whitespace-only
+    type: "custom"
+  };
+  await saveUserRegistry(userRegistry);
+  import_core.logger.info(`Added custom agent '${agentId}' to user registry`);
+}
+async function removeAgentFromUserRegistry(agentId) {
+  const userRegistry = loadUserRegistry();
+  if (!(agentId in userRegistry.agents)) {
+    throw import_errors.RegistryError.agentNotFound(agentId, Object.keys(userRegistry.agents));
+  }
+  delete userRegistry.agents[agentId];
+  await saveUserRegistry(userRegistry);
+  import_core.logger.info(`Removed custom agent '${agentId}' from user registry`);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addAgentToUserRegistry,
+  getUserRegistryPath,
+  loadUserRegistry,
+  mergeRegistries,
+  removeAgentFromUserRegistry,
+  saveUserRegistry,
+  userRegistryHasAgent
+});

package/dist/registry/user-registry.d.ts

@@ -0,0 +1,34 @@
+import { Registry, AgentRegistryEntry } from './types.js';
+/**
+ * Get path to user registry file
+ */
+export declare function getUserRegistryPath(): string;
+/**
+ * Load user registry from ~/.dexto/user-agent-registry.json
+ * Returns empty registry if file doesn't exist
+ */
+export declare function loadUserRegistry(): Registry;
+/**
+ * Save user registry atomically using temp file + rename
+ */
+export declare function saveUserRegistry(registry: Registry): Promise<void>;
+/**
+ * Merge bundled and user registries
+ * User registry only contains custom agents
+ * Name conflicts are not allowed (validated before adding to user registry)
+ */
+export declare function mergeRegistries(bundled: Registry, user: Registry): Registry;
+/**
+ * Check if agent exists in user registry
+ */
+export declare function userRegistryHasAgent(agentId: string): boolean;
+/**
+ * Add custom agent to user registry
+ * Validates that name doesn't conflict with bundled registry
+ */
+export declare function addAgentToUserRegistry(agentId: string, entry: Omit<AgentRegistryEntry, 'type'>): Promise<void>;
+/**
+ * Remove custom agent from user registry
+ */
+export declare function removeAgentFromUserRegistry(agentId: string): Promise<void>;
+//# sourceMappingURL=user-registry.d.ts.map

package/dist/registry/user-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"user-registry.d.ts","sourceRoot":"","sources":["../../src/registry/user-registry.ts"],"names":[],"mappings":"AAIA,OAAO,EACH,QAAQ,EAER,kBAAkB,EAGrB,MAAM,YAAY,CAAC;AAMpB;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAE5C;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,IAAI,QAAQ,CAkB3C;AAED;;GAEG;AACH,wBAAsB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCxE;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAQ3E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAG7D;AAED;;;GAGG;AACH,wBAAsB,sBAAsB,CACxC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,IAAI,CAAC,kBAAkB,EAAE,MAAM,CAAC,GACxC,OAAO,CAAC,IAAI,CAAC,CAkBf;AAED;;GAEG;AACH,wBAAsB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAWhF"}

package/dist/registry/user-registry.js

@@ -0,0 +1,104 @@
+import { promises as fs, readFileSync } from "fs";
+import { existsSync } from "fs";
+import path from "path";
+import { getDextoGlobalPath } from "../utils/path.js";
+import {
+  RegistrySchema,
+  normalizeRegistryJson,
+  deriveDisplayName
+} from "./types.js";
+import { RegistryError } from "./errors.js";
+import { logger } from "@dexto/core";
+const USER_REGISTRY_FILENAME = "user-agent-registry.json";
+function getUserRegistryPath() {
+  return getDextoGlobalPath("", USER_REGISTRY_FILENAME);
+}
+function loadUserRegistry() {
+  const registryPath = getUserRegistryPath();
+  if (!existsSync(registryPath)) {
+    logger.debug("User registry not found, returning empty registry");
+    return { version: "1.0.0", agents: {} };
+  }
+  try {
+    const content = readFileSync(registryPath, "utf-8");
+    const data = JSON.parse(content);
+    return RegistrySchema.parse(normalizeRegistryJson(data));
+  } catch (error) {
+    throw RegistryError.registryParseError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveUserRegistry(registry) {
+  const registryPath = getUserRegistryPath();
+  const tempPath = `${registryPath}.tmp.${Date.now()}`;
+  const dextoDir = path.dirname(registryPath);
+  try {
+    await fs.mkdir(dextoDir, { recursive: true });
+    await fs.writeFile(tempPath, JSON.stringify(registry, null, 2), {
+      encoding: "utf-8",
+      mode: 384
+    });
+    await fs.rename(tempPath, registryPath);
+    logger.debug(`Saved user registry to ${registryPath}`);
+  } catch (error) {
+    try {
+      if (existsSync(tempPath)) {
+        await fs.rm(tempPath, { force: true });
+      }
+    } catch {
+    }
+    throw RegistryError.registryWriteError(
+      registryPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function mergeRegistries(bundled, user) {
+  return {
+    version: bundled.version,
+    agents: {
+      ...bundled.agents,
+      ...user.agents
+    }
+  };
+}
+function userRegistryHasAgent(agentId) {
+  const userRegistry = loadUserRegistry();
+  return agentId in userRegistry.agents;
+}
+async function addAgentToUserRegistry(agentId, entry) {
+  const userRegistry = loadUserRegistry();
+  if (agentId in userRegistry.agents) {
+    throw RegistryError.agentAlreadyExists(agentId);
+  }
+  userRegistry.agents[agentId] = {
+    ...entry,
+    id: agentId,
+    // Force consistency between key and id field
+    name: entry.name && entry.name.trim().length > 0 ? entry.name : deriveDisplayName(agentId),
+    // Ensure name is never undefined or whitespace-only
+    type: "custom"
+  };
+  await saveUserRegistry(userRegistry);
+  logger.info(`Added custom agent '${agentId}' to user registry`);
+}
+async function removeAgentFromUserRegistry(agentId) {
+  const userRegistry = loadUserRegistry();
+  if (!(agentId in userRegistry.agents)) {
+    throw RegistryError.agentNotFound(agentId, Object.keys(userRegistry.agents));
+  }
+  delete userRegistry.agents[agentId];
+  await saveUserRegistry(userRegistry);
+  logger.info(`Removed custom agent '${agentId}' from user registry`);
+}
+export {
+  addAgentToUserRegistry,
+  getUserRegistryPath,
+  loadUserRegistry,
+  mergeRegistries,
+  removeAgentFromUserRegistry,
+  saveUserRegistry,
+  userRegistryHasAgent
+};

package/dist/resolver.cjs

@@ -0,0 +1,182 @@
+"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 resolver_exports = {};
+__export(resolver_exports, {
+  resolveAgentPath: () => resolveAgentPath,
+  updateDefaultAgentPreference: () => updateDefaultAgentPreference
+});
+module.exports = __toCommonJS(resolver_exports);
+var import_fs = require("fs");
+var import_path = __toESM(require("path"), 1);
+var import_path2 = require("./utils/path.js");
+var import_execution_context = require("./utils/execution-context.js");
+var import_core = require("@dexto/core");
+var import_loader = require("./preferences/loader.js");
+var import_config = require("./config/index.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_config.ConfigError.fileNotFound(resolved);
+      }
+      return resolved;
+    } catch {
+      throw import_config.ConfigError.fileNotFound(resolved);
+    }
+  }
+  if (nameOrPath) {
+    const { getAgentRegistry } = await import("./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 = (0, import_execution_context.getExecutionContext)();
+  switch (executionContext) {
+    case "dexto-source":
+      return await resolveDefaultAgentForDextoSource(autoInstall, injectPreferences);
+    case "dexto-project":
+      return await resolveDefaultAgentForDextoProject(autoInstall, injectPreferences);
+    case "global-cli":
+      return await resolveDefaultAgentForGlobalCLI(autoInstall, injectPreferences);
+    default:
+      throw import_config.ConfigError.unknownContext(executionContext);
+  }
+}
+async function resolveDefaultAgentForDextoSource(autoInstall = true, injectPreferences = true) {
+  import_core.logger.debug("Resolving default agent for dexto source context");
+  const sourceRoot = (0, import_execution_context.findDextoSourceRoot)();
+  if (!sourceRoot) {
+    throw import_config.ConfigError.bundledNotFound("dexto source directory not found");
+  }
+  const repoConfigPath = import_path.default.join(sourceRoot, "agents", "default-agent.yml");
+  const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+  if (isDevMode) {
+    import_core.logger.debug("Dev mode: using repository config file");
+    try {
+      await import_fs.promises.access(repoConfigPath);
+      return repoConfigPath;
+    } catch {
+      throw import_config.ConfigError.bundledNotFound(repoConfigPath);
+    }
+  }
+  if ((0, import_loader.globalPreferencesExist)()) {
+    try {
+      const preferences = await (0, import_loader.loadGlobalPreferences)();
+      if (preferences.setup.completed) {
+        import_core.logger.debug("Using user preferences in dexto-source context");
+        const preferredAgentName = preferences.defaults.defaultAgent;
+        const { getAgentRegistry } = await import("./registry/registry.js");
+        const registry = getAgentRegistry();
+        return await registry.resolveAgent(
+          preferredAgentName,
+          autoInstall,
+          injectPreferences
+        );
+      }
+    } catch (error) {
+      import_core.logger.warn(`Failed to load preferences, falling back to repo config: ${error}`);
+    }
+  }
+  import_core.logger.debug("Using repository config (no preferences or setup incomplete)");
+  try {
+    await import_fs.promises.access(repoConfigPath);
+    return repoConfigPath;
+  } catch {
+    throw import_config.ConfigError.bundledNotFound(repoConfigPath);
+  }
+}
+async function resolveDefaultAgentForDextoProject(autoInstall = true, injectPreferences = true) {
+  import_core.logger.debug("Resolving default agent for dexto project context");
+  const projectRoot = (0, import_execution_context.findDextoProjectRoot)();
+  if (!projectRoot) {
+    throw import_config.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_core.logger.debug(`No project-local default-agent.yml found in ${projectRoot}`);
+  if (!(0, import_loader.globalPreferencesExist)()) {
+    throw import_config.ConfigError.noProjectDefault(projectRoot);
+  }
+  const preferences = await (0, import_loader.loadGlobalPreferences)();
+  if (!preferences.setup.completed) {
+    throw import_config.ConfigError.setupIncomplete();
+  }
+  const preferredAgentName = preferences.defaults.defaultAgent;
+  const { getAgentRegistry } = await import("./registry/registry.js");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function resolveDefaultAgentForGlobalCLI(autoInstall = true, injectPreferences = true) {
+  import_core.logger.debug("Resolving default agent for global CLI context");
+  if (!(0, import_loader.globalPreferencesExist)()) {
+    throw import_config.ConfigError.noGlobalPreferences();
+  }
+  const preferences = await (0, import_loader.loadGlobalPreferences)();
+  if (!preferences.setup.completed) {
+    throw import_config.ConfigError.setupIncomplete();
+  }
+  const preferredAgentName = preferences.defaults.defaultAgent;
+  const { getAgentRegistry } = await import("./registry/registry.js");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function updateDefaultAgentPreference(agentName) {
+  const { getAgentRegistry } = await import("./registry/registry.js");
+  const { RegistryError } = await import("./registry/errors.js");
+  const { isPath: isPath2 } = await import("@dexto/core");
+  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 }
+  });
+  import_core.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/resolver.d.ts

@@ -0,0 +1,14 @@
+/**
+ * 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
+ */
+export declare function resolveAgentPath(nameOrPath?: string, autoInstall?: boolean, injectPreferences?: boolean): Promise<string>;
+/**
+ * Update default agent preference
+ */
+export declare function updateDefaultAgentPreference(agentName: string): Promise<void>;
+//# sourceMappingURL=resolver.d.ts.map

package/dist/resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolver.d.ts","sourceRoot":"","sources":["../src/resolver.ts"],"names":[],"mappings":"AAcA;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CAClC,UAAU,CAAC,EAAE,MAAM,EACnB,WAAW,GAAE,OAAc,EAC3B,iBAAiB,GAAE,OAAc,GAClC,OAAO,CAAC,MAAM,CAAC,CAyBjB;AAoKD;;GAEG;AACH,wBAAsB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAoBnF"}

package/dist/resolver.js

@@ -0,0 +1,151 @@
+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 { logger } from "@dexto/core";
+import { loadGlobalPreferences, globalPreferencesExist } from "./preferences/loader.js";
+import { ConfigError } from "./config/index.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("./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(autoInstall, injectPreferences);
+    case "dexto-project":
+      return await resolveDefaultAgentForDextoProject(autoInstall, injectPreferences);
+    case "global-cli":
+      return await resolveDefaultAgentForGlobalCLI(autoInstall, injectPreferences);
+    default:
+      throw ConfigError.unknownContext(executionContext);
+  }
+}
+async function resolveDefaultAgentForDextoSource(autoInstall = true, injectPreferences = true) {
+  logger.debug("Resolving default agent for dexto source context");
+  const sourceRoot = findDextoSourceRoot();
+  if (!sourceRoot) {
+    throw ConfigError.bundledNotFound("dexto source directory not found");
+  }
+  const repoConfigPath = path.join(sourceRoot, "agents", "default-agent.yml");
+  const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+  if (isDevMode) {
+    logger.debug("Dev mode: using repository config file");
+    try {
+      await fs.access(repoConfigPath);
+      return repoConfigPath;
+    } catch {
+      throw ConfigError.bundledNotFound(repoConfigPath);
+    }
+  }
+  if (globalPreferencesExist()) {
+    try {
+      const preferences = await loadGlobalPreferences();
+      if (preferences.setup.completed) {
+        logger.debug("Using user preferences in dexto-source context");
+        const preferredAgentName = preferences.defaults.defaultAgent;
+        const { getAgentRegistry } = await import("./registry/registry.js");
+        const registry = getAgentRegistry();
+        return await registry.resolveAgent(
+          preferredAgentName,
+          autoInstall,
+          injectPreferences
+        );
+      }
+    } catch (error) {
+      logger.warn(`Failed to load preferences, falling back to repo config: ${error}`);
+    }
+  }
+  logger.debug("Using repository config (no preferences or setup incomplete)");
+  try {
+    await fs.access(repoConfigPath);
+    return repoConfigPath;
+  } catch {
+    throw ConfigError.bundledNotFound(repoConfigPath);
+  }
+}
+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("./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("./registry/registry.js");
+  const registry = getAgentRegistry();
+  return await registry.resolveAgent(preferredAgentName, autoInstall, injectPreferences);
+}
+async function updateDefaultAgentPreference(agentName) {
+  const { getAgentRegistry } = await import("./registry/registry.js");
+  const { RegistryError } = await import("./registry/errors.js");
+  const { isPath: isPath2 } = await import("@dexto/core");
+  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
+};