@dexto/agent-management 1.2.5

package/dist/utils/fs-walk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs-walk.d.ts","sourceRoot":"","sources":["../../src/utils/fs-walk.ts"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,MAAM,EACjB,SAAS,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,OAAO,GACxC,MAAM,GAAG,IAAI,CAef"}

package/dist/utils/fs-walk.js

@@ -0,0 +1,18 @@
+import * as path from "path";
+function walkUpDirectories(startPath, predicate) {
+  let currentPath = path.resolve(startPath);
+  const rootPath = path.parse(currentPath).root;
+  while (true) {
+    if (predicate(currentPath)) {
+      return currentPath;
+    }
+    if (currentPath === rootPath) break;
+    const parent = path.dirname(currentPath);
+    if (parent === currentPath) break;
+    currentPath = parent;
+  }
+  return null;
+}
+export {
+  walkUpDirectories
+};

package/dist/utils/path.cjs

@@ -0,0 +1,205 @@
+"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 path_exports = {};
+__export(path_exports, {
+  copyDirectory: () => copyDirectory,
+  ensureDextoGlobalDirectory: () => ensureDextoGlobalDirectory,
+  findPackageRoot: () => findPackageRoot,
+  getDextoEnvPath: () => getDextoEnvPath,
+  getDextoGlobalPath: () => getDextoGlobalPath,
+  getDextoPath: () => getDextoPath,
+  isPath: () => isPath,
+  resolveBundledScript: () => resolveBundledScript
+});
+module.exports = __toCommonJS(path_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_os = require("os");
+var import_module = require("module");
+var import_url = require("url");
+var import_fs_walk = require("./fs-walk.js");
+var import_execution_context = require("./execution-context.js");
+const import_meta = {};
+function getDextoPath(type, filename, startPath) {
+  const context = (0, import_execution_context.getExecutionContext)(startPath);
+  let basePath;
+  switch (context) {
+    case "dexto-source": {
+      const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+      if (isDevMode) {
+        const sourceRoot = (0, import_execution_context.findDextoSourceRoot)(startPath);
+        if (!sourceRoot) {
+          throw new Error("Not in dexto source context");
+        }
+        basePath = path.join(sourceRoot, ".dexto", type);
+      } else {
+        basePath = path.join((0, import_os.homedir)(), ".dexto", type);
+      }
+      break;
+    }
+    case "dexto-project": {
+      const projectRoot = (0, import_execution_context.findDextoProjectRoot)(startPath);
+      if (!projectRoot) {
+        throw new Error("Not in dexto project context");
+      }
+      basePath = path.join(projectRoot, ".dexto", type);
+      break;
+    }
+    case "global-cli": {
+      basePath = path.join((0, import_os.homedir)(), ".dexto", type);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown execution context: ${context}`);
+    }
+  }
+  return filename ? path.join(basePath, filename) : basePath;
+}
+function getDextoGlobalPath(type, filename) {
+  const basePath = path.join((0, import_os.homedir)(), ".dexto", type);
+  return filename ? path.join(basePath, filename) : basePath;
+}
+async function copyDirectory(src, dest) {
+  await import_fs2.promises.mkdir(dest, { recursive: true });
+  const entries = await import_fs2.promises.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await import_fs2.promises.copyFile(srcPath, destPath);
+    }
+  }
+}
+function isPath(str) {
+  if (path.isAbsolute(str)) return true;
+  if (/[\\/]/.test(str)) return true;
+  if (/\.(ya?ml|json)$/i.test(str)) return true;
+  return false;
+}
+function findPackageRoot(startPath = process.cwd()) {
+  return (0, import_fs_walk.walkUpDirectories)(startPath, (dirPath) => {
+    const pkgPath = path.join(dirPath, "package.json");
+    return (0, import_fs.existsSync)(pkgPath);
+  });
+}
+function resolveBundledScript(scriptPath) {
+  const candidates = scriptPath.startsWith("dist/") ? [scriptPath, scriptPath.replace(/^dist\//, "")] : [`dist/${scriptPath}`, scriptPath];
+  const triedAbs = [];
+  const tryRoots = (roots) => {
+    for (const root of roots) {
+      if (!root) continue;
+      for (const rel of candidates) {
+        const abs = path.resolve(root, rel);
+        if ((0, import_fs.existsSync)(abs)) return abs;
+        triedAbs.push(abs);
+      }
+    }
+    return null;
+  };
+  const envRoot = process?.env?.DEXTO_PACKAGE_ROOT;
+  const fromEnv = tryRoots([envRoot]);
+  if (fromEnv) return fromEnv;
+  try {
+    const require2 = (0, import_module.createRequire)(import_meta.url);
+    const pkgJson = require2.resolve("dexto/package.json");
+    const pkgRoot = path.dirname(pkgJson);
+    const fromPkg = tryRoots([pkgRoot]);
+    if (fromPkg) return fromPkg;
+  } catch {
+  }
+  try {
+    const thisModuleDir = path.dirname((0, import_url.fileURLToPath)(import_meta.url));
+    const sourceRoot = (0, import_execution_context.findDextoSourceRoot)(thisModuleDir);
+    const fromSource = tryRoots([sourceRoot ?? void 0]);
+    if (fromSource) return fromSource;
+  } catch {
+  }
+  const repoRoot = findPackageRoot();
+  const fromCwd = tryRoots([repoRoot ?? void 0]);
+  if (fromCwd) return fromCwd;
+  throw new Error(
+    `Bundled script not found: ${scriptPath} (tried absolute: ${triedAbs.join(", ")})`
+  );
+}
+async function ensureDextoGlobalDirectory() {
+  const dextoDir = path.join((0, import_os.homedir)(), ".dexto");
+  try {
+    await import_fs2.promises.mkdir(dextoDir, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function getDextoEnvPath(startPath = process.cwd()) {
+  const context = (0, import_execution_context.getExecutionContext)(startPath);
+  let envPath = "";
+  switch (context) {
+    case "dexto-source": {
+      const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+      if (isDevMode) {
+        const sourceRoot = (0, import_execution_context.findDextoSourceRoot)(startPath);
+        if (!sourceRoot) {
+          throw new Error("Not in dexto source context");
+        }
+        envPath = path.join(sourceRoot, ".env");
+      } else {
+        envPath = path.join((0, import_os.homedir)(), ".dexto", ".env");
+      }
+      break;
+    }
+    case "dexto-project": {
+      const projectRoot = (0, import_execution_context.findDextoProjectRoot)(startPath);
+      if (!projectRoot) {
+        throw new Error("Not in dexto project context");
+      }
+      envPath = path.join(projectRoot, ".env");
+      break;
+    }
+    case "global-cli": {
+      envPath = path.join((0, import_os.homedir)(), ".dexto", ".env");
+      break;
+    }
+  }
+  return envPath;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  copyDirectory,
+  ensureDextoGlobalDirectory,
+  findPackageRoot,
+  getDextoEnvPath,
+  getDextoGlobalPath,
+  getDextoPath,
+  isPath,
+  resolveBundledScript
+});

package/dist/utils/path.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Standard path resolver for logs/db/config/anything in dexto projects
+ * Context-aware with dev mode support:
+ * - dexto-source + DEXTO_DEV_MODE=true: Use local repo .dexto (isolated testing)
+ * - dexto-source (normal): Use global ~/.dexto (user experience)
+ * - dexto-project: Use project-local .dexto
+ * - global-cli: Use global ~/.dexto
+ * @param type Path type (logs, database, config, etc.)
+ * @param filename Optional filename to append
+ * @param startPath Starting directory for project detection
+ * @returns Absolute path to the requested location
+ */
+export declare function getDextoPath(type: string, filename?: string, startPath?: string): string;
+/**
+ * Global path resolver that ALWAYS returns paths in the user's home directory
+ * Used for agent registry and other global-only resources that should not be project-relative
+ * @param type Path type (agents, cache, etc.)
+ * @param filename Optional filename to append
+ * @returns Absolute path to the global location (~/.dexto/...)
+ */
+export declare function getDextoGlobalPath(type: string, filename?: string): string;
+/**
+ * Copy entire directory recursively
+ * @param src Source directory path
+ * @param dest Destination directory path
+ */
+export declare function copyDirectory(src: string, dest: string): Promise<void>;
+/**
+ * Check if string looks like a file path vs registry name
+ * @param str String to check
+ * @returns True if looks like a path, false if looks like a registry name
+ */
+export declare function isPath(str: string): boolean;
+/**
+ * Find package root (for other utilities)
+ * @param startPath Starting directory path
+ * @returns Directory containing package.json or null
+ */
+export declare function findPackageRoot(startPath?: string): string | null;
+/**
+ * Resolve bundled script paths for MCP servers
+ * @param scriptPath Relative script path
+ * @returns Absolute path to bundled script
+ */
+export declare function resolveBundledScript(scriptPath: string): string;
+/**
+ * Ensure ~/.dexto directory exists for global storage
+ */
+export declare function ensureDextoGlobalDirectory(): Promise<void>;
+/**
+ * Get the appropriate .env file path for saving API keys.
+ * Uses the same project detection logic as other dexto paths.
+ *
+ * @param startPath Starting directory for project detection
+ * @returns Absolute path to .env file for saving
+ */
+export declare function getDextoEnvPath(startPath?: string): string;
+//# sourceMappingURL=path.d.ts.map

package/dist/utils/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/utils/path.ts"],"names":[],"mappings":"AAgBA;;;;;;;;;;;GAWG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,MAAM,CAuCxF;AAED;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAI1E;AAED;;;;GAIG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAW3C;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,GAAG,IAAI,CAKhF;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAwD/D;AAED;;GAEG;AACH,wBAAsB,0BAA0B,IAAI,OAAO,CAAC,IAAI,CAAC,CAUhE;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,SAAS,GAAE,MAAsB,GAAG,MAAM,CAkCzE"}

package/dist/utils/path.js

@@ -0,0 +1,167 @@
+import * as path from "path";
+import { existsSync } from "fs";
+import { promises as fs } from "fs";
+import { homedir } from "os";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { walkUpDirectories } from "./fs-walk.js";
+import {
+  getExecutionContext,
+  findDextoSourceRoot,
+  findDextoProjectRoot
+} from "./execution-context.js";
+function getDextoPath(type, filename, startPath) {
+  const context = getExecutionContext(startPath);
+  let basePath;
+  switch (context) {
+    case "dexto-source": {
+      const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+      if (isDevMode) {
+        const sourceRoot = findDextoSourceRoot(startPath);
+        if (!sourceRoot) {
+          throw new Error("Not in dexto source context");
+        }
+        basePath = path.join(sourceRoot, ".dexto", type);
+      } else {
+        basePath = path.join(homedir(), ".dexto", type);
+      }
+      break;
+    }
+    case "dexto-project": {
+      const projectRoot = findDextoProjectRoot(startPath);
+      if (!projectRoot) {
+        throw new Error("Not in dexto project context");
+      }
+      basePath = path.join(projectRoot, ".dexto", type);
+      break;
+    }
+    case "global-cli": {
+      basePath = path.join(homedir(), ".dexto", type);
+      break;
+    }
+    default: {
+      throw new Error(`Unknown execution context: ${context}`);
+    }
+  }
+  return filename ? path.join(basePath, filename) : basePath;
+}
+function getDextoGlobalPath(type, filename) {
+  const basePath = path.join(homedir(), ".dexto", type);
+  return filename ? path.join(basePath, filename) : basePath;
+}
+async function copyDirectory(src, dest) {
+  await fs.mkdir(dest, { recursive: true });
+  const entries = await fs.readdir(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath);
+    } else {
+      await fs.copyFile(srcPath, destPath);
+    }
+  }
+}
+function isPath(str) {
+  if (path.isAbsolute(str)) return true;
+  if (/[\\/]/.test(str)) return true;
+  if (/\.(ya?ml|json)$/i.test(str)) return true;
+  return false;
+}
+function findPackageRoot(startPath = process.cwd()) {
+  return walkUpDirectories(startPath, (dirPath) => {
+    const pkgPath = path.join(dirPath, "package.json");
+    return existsSync(pkgPath);
+  });
+}
+function resolveBundledScript(scriptPath) {
+  const candidates = scriptPath.startsWith("dist/") ? [scriptPath, scriptPath.replace(/^dist\//, "")] : [`dist/${scriptPath}`, scriptPath];
+  const triedAbs = [];
+  const tryRoots = (roots) => {
+    for (const root of roots) {
+      if (!root) continue;
+      for (const rel of candidates) {
+        const abs = path.resolve(root, rel);
+        if (existsSync(abs)) return abs;
+        triedAbs.push(abs);
+      }
+    }
+    return null;
+  };
+  const envRoot = process?.env?.DEXTO_PACKAGE_ROOT;
+  const fromEnv = tryRoots([envRoot]);
+  if (fromEnv) return fromEnv;
+  try {
+    const require2 = createRequire(import.meta.url);
+    const pkgJson = require2.resolve("dexto/package.json");
+    const pkgRoot = path.dirname(pkgJson);
+    const fromPkg = tryRoots([pkgRoot]);
+    if (fromPkg) return fromPkg;
+  } catch {
+  }
+  try {
+    const thisModuleDir = path.dirname(fileURLToPath(import.meta.url));
+    const sourceRoot = findDextoSourceRoot(thisModuleDir);
+    const fromSource = tryRoots([sourceRoot ?? void 0]);
+    if (fromSource) return fromSource;
+  } catch {
+  }
+  const repoRoot = findPackageRoot();
+  const fromCwd = tryRoots([repoRoot ?? void 0]);
+  if (fromCwd) return fromCwd;
+  throw new Error(
+    `Bundled script not found: ${scriptPath} (tried absolute: ${triedAbs.join(", ")})`
+  );
+}
+async function ensureDextoGlobalDirectory() {
+  const dextoDir = path.join(homedir(), ".dexto");
+  try {
+    await fs.mkdir(dextoDir, { recursive: true });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
+  }
+}
+function getDextoEnvPath(startPath = process.cwd()) {
+  const context = getExecutionContext(startPath);
+  let envPath = "";
+  switch (context) {
+    case "dexto-source": {
+      const isDevMode = process.env.DEXTO_DEV_MODE === "true";
+      if (isDevMode) {
+        const sourceRoot = findDextoSourceRoot(startPath);
+        if (!sourceRoot) {
+          throw new Error("Not in dexto source context");
+        }
+        envPath = path.join(sourceRoot, ".env");
+      } else {
+        envPath = path.join(homedir(), ".dexto", ".env");
+      }
+      break;
+    }
+    case "dexto-project": {
+      const projectRoot = findDextoProjectRoot(startPath);
+      if (!projectRoot) {
+        throw new Error("Not in dexto project context");
+      }
+      envPath = path.join(projectRoot, ".env");
+      break;
+    }
+    case "global-cli": {
+      envPath = path.join(homedir(), ".dexto", ".env");
+      break;
+    }
+  }
+  return envPath;
+}
+export {
+  copyDirectory,
+  ensureDextoGlobalDirectory,
+  findPackageRoot,
+  getDextoEnvPath,
+  getDextoGlobalPath,
+  getDextoPath,
+  isPath,
+  resolveBundledScript
+};

package/dist/writer.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 writer_exports = {};
+__export(writer_exports, {
+  writeConfigFile: () => writeConfigFile,
+  writeLLMPreferences: () => writeLLMPreferences,
+  writePreferencesToAgent: () => writePreferencesToAgent
+});
+module.exports = __toCommonJS(writer_exports);
+var import_fs = require("fs");
+var import_yaml = require("yaml");
+var path = __toESM(require("path"), 1);
+var import_core = require("@dexto/core");
+var import_config = require("./config/index.js");
+async function writeConfigFile(configPath, config) {
+  const absolutePath = path.resolve(configPath);
+  try {
+    const yamlContent = (0, import_yaml.stringify)(config, { indent: 2 });
+    await import_fs.promises.writeFile(absolutePath, yamlContent, "utf-8");
+    import_core.logger.debug(`Wrote dexto config to: ${absolutePath}`);
+  } catch (error) {
+    throw import_config.ConfigError.fileWriteError(
+      absolutePath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function writeLLMPreferences(configPath, preferences, overrides) {
+  import_core.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)
+  });
+  import_core.logger.debug(`Reading config file: ${configPath}`);
+  let fileContent;
+  try {
+    fileContent = await import_fs.promises.readFile(configPath, "utf-8");
+    import_core.logger.debug(`Successfully read config file (${fileContent.length} chars)`);
+  } catch (error) {
+    import_core.logger.error(`Failed to read config file: ${configPath}`, { error });
+    throw import_config.ConfigError.fileReadError(
+      configPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  let config;
+  try {
+    config = (0, import_yaml.parse)(fileContent);
+    import_core.logger.debug(`Successfully parsed YAML config`, {
+      hasLlmSection: Boolean(config.llm),
+      existingProvider: config.llm?.provider,
+      existingModel: config.llm?.model
+    });
+  } catch (error) {
+    import_core.logger.error(`Failed to parse YAML config: ${configPath}`, { error });
+    throw import_config.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;
+  import_core.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);
+  import_core.logger.info(`\u2713 Applied preferences to: ${path.basename(configPath)} (${provider}/${model})`);
+}
+async function writePreferencesToAgent(installedPath, preferences, overrides) {
+  let stat;
+  try {
+    stat = await import_fs.promises.stat(installedPath);
+  } catch (error) {
+    throw import_config.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);
+      import_core.logger.info(`\u2713 Applied preferences to: ${path.basename(installedPath)}`, null, "green");
+    } else {
+      import_core.logger.warn(`Skipping non-YAML file: ${installedPath}`, null, "yellow");
+    }
+  } else if (stat.isDirectory()) {
+    await writePreferencesToDirectory(installedPath, preferences, overrides);
+  } else {
+    throw import_config.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) {
+    import_core.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);
+      import_core.logger.debug(`Applied preferences to: ${path.relative(installedDir, configPath)}`);
+      successCount++;
+    } catch (error) {
+      import_core.logger.warn(
+        `Failed to write preferences to ${configPath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  import_core.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 import_fs.promises.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  writeConfigFile,
+  writeLLMPreferences,
+  writePreferencesToAgent
+});

package/dist/writer.d.ts

@@ -0,0 +1,34 @@
+import type { LLMProvider, AgentConfig } from '@dexto/core';
+import { type GlobalPreferences } from './preferences/schemas.js';
+export interface LLMOverrides {
+    provider?: LLMProvider;
+    model?: string;
+    apiKey?: string;
+}
+/**
+ * Asynchronously writes the given agent configuration object to a YAML file.
+ * This function handles the serialization of the config object to YAML format
+ * and writes it to the specified file path.
+ *
+ * @param configPath - Path where the configuration file should be written (absolute or relative)
+ * @param config - The `AgentConfig` object to be written to the file
+ * @returns A Promise that resolves when the file has been successfully written
+ * @throws {ConfigError} with FILE_WRITE_ERROR if an error occurs during YAML stringification or file writing
+ */
+export declare function writeConfigFile(configPath: string, config: AgentConfig): Promise<void>;
+/**
+ * Write global LLM preferences to an agent config file
+ * @param configPath Absolute path to agent configuration file
+ * @param preferences Global preferences to write
+ * @param overrides Optional CLI overrides
+ * @throws DextoRuntimeError for write failures
+ */
+export declare function writeLLMPreferences(configPath: string, preferences: GlobalPreferences, overrides?: LLMOverrides): Promise<void>;
+/**
+ * Write preferences to an installed agent (file or directory)
+ * @param installedPath Path to installed agent file or directory
+ * @param preferences Global preferences to write
+ * @param overrides Optional CLI overrides
+ */
+export declare function writePreferencesToAgent(installedPath: string, preferences: GlobalPreferences, overrides?: LLMOverrides): Promise<void>;
+//# sourceMappingURL=writer.d.ts.map

package/dist/writer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writer.d.ts","sourceRoot":"","sources":["../src/writer.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,EAAE,KAAK,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAIlE,MAAM,WAAW,YAAY;IACzB,QAAQ,CAAC,EAAE,WAAW,CAAC;IACvB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAqB5F;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CACrC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,iBAAiB,EAC9B,SAAS,CAAC,EAAE,YAAY,GACzB,OAAO,CAAC,IAAI,CAAC,CAiEf;AAED;;;;;GAKG;AACH,wBAAsB,uBAAuB,CACzC,aAAa,EAAE,MAAM,EACrB,WAAW,EAAE,iBAAiB,EAC9B,SAAS,CAAC,EAAE,YAAY,GACzB,OAAO,CAAC,IAAI,CAAC,CAyBf"}