@dexto/core 1.1.4 → 1.1.6

package/dist/preferences/constants.d.ts

@@ -0,0 +1,3 @@
+declare const PREFERENCES_FILE = "preferences.yml";
+
+export { PREFERENCES_FILE };

package/dist/preferences/constants.js

@@ -0,0 +1,4 @@
+const PREFERENCES_FILE = "preferences.yml";
+export {
+  PREFERENCES_FILE
+};

package/dist/preferences/error-codes.cjs

@@ -0,0 +1,35 @@
+"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, {
+  PreferenceErrorCode: () => PreferenceErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var PreferenceErrorCode = /* @__PURE__ */ ((PreferenceErrorCode2) => {
+  PreferenceErrorCode2["FILE_NOT_FOUND"] = "preference_file_not_found";
+  PreferenceErrorCode2["FILE_READ_ERROR"] = "preference_file_read_error";
+  PreferenceErrorCode2["FILE_WRITE_ERROR"] = "preference_file_write_error";
+  PreferenceErrorCode2["VALIDATION_ERROR"] = "preference_validation_error";
+  PreferenceErrorCode2["MODEL_INCOMPATIBLE"] = "preference_model_incompatible";
+  return PreferenceErrorCode2;
+})(PreferenceErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PreferenceErrorCode
+});

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

@@ -0,0 +1,9 @@
+declare enum PreferenceErrorCode {
+    FILE_NOT_FOUND = "preference_file_not_found",
+    FILE_READ_ERROR = "preference_file_read_error",
+    FILE_WRITE_ERROR = "preference_file_write_error",
+    VALIDATION_ERROR = "preference_validation_error",
+    MODEL_INCOMPATIBLE = "preference_model_incompatible"
+}
+
+export { PreferenceErrorCode };

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

@@ -0,0 +1,9 @@
+declare enum PreferenceErrorCode {
+    FILE_NOT_FOUND = "preference_file_not_found",
+    FILE_READ_ERROR = "preference_file_read_error",
+    FILE_WRITE_ERROR = "preference_file_write_error",
+    VALIDATION_ERROR = "preference_validation_error",
+    MODEL_INCOMPATIBLE = "preference_model_incompatible"
+}
+
+export { PreferenceErrorCode };

package/dist/preferences/error-codes.js

@@ -0,0 +1,11 @@
+var PreferenceErrorCode = /* @__PURE__ */ ((PreferenceErrorCode2) => {
+  PreferenceErrorCode2["FILE_NOT_FOUND"] = "preference_file_not_found";
+  PreferenceErrorCode2["FILE_READ_ERROR"] = "preference_file_read_error";
+  PreferenceErrorCode2["FILE_WRITE_ERROR"] = "preference_file_write_error";
+  PreferenceErrorCode2["VALIDATION_ERROR"] = "preference_validation_error";
+  PreferenceErrorCode2["MODEL_INCOMPATIBLE"] = "preference_model_incompatible";
+  return PreferenceErrorCode2;
+})(PreferenceErrorCode || {});
+export {
+  PreferenceErrorCode
+};

package/dist/preferences/errors.cjs

@@ -0,0 +1,75 @@
+"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, {
+  PreferenceError: () => PreferenceError,
+  PreferenceErrorCode: () => import_error_codes2.PreferenceErrorCode
+});
+module.exports = __toCommonJS(errors_exports);
+var import_errors = require("../errors/index.cjs");
+var import_types = require("../errors/types.cjs");
+var import_error_codes = require("./error-codes.js");
+var import_error_codes2 = require("./error-codes.js");
+class PreferenceError {
+  static fileNotFound(preferencesPath) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.PreferenceErrorCode.FILE_NOT_FOUND,
+      import_types.ErrorScope.PREFERENCE,
+      import_types.ErrorType.USER,
+      `Preferences file not found: ${preferencesPath}`,
+      { preferencesPath },
+      "Run `dexto setup` to create preferences"
+    );
+  }
+  static fileReadError(preferencesPath, cause) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.PreferenceErrorCode.FILE_READ_ERROR,
+      import_types.ErrorScope.PREFERENCE,
+      import_types.ErrorType.SYSTEM,
+      `Failed to read preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and ensure the file is not corrupted"
+    );
+  }
+  static fileWriteError(preferencesPath, cause) {
+    return new import_errors.DextoRuntimeError(
+      import_error_codes.PreferenceErrorCode.FILE_WRITE_ERROR,
+      import_types.ErrorScope.PREFERENCE,
+      import_types.ErrorType.SYSTEM,
+      `Failed to save preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and available disk space"
+    );
+  }
+  static validationFailed(zodError) {
+    const issues = zodError.issues.map((issue) => ({
+      code: import_error_codes.PreferenceErrorCode.VALIDATION_ERROR,
+      message: `${issue.path.join(".")}: ${issue.message}`,
+      scope: import_types.ErrorScope.PREFERENCE,
+      type: import_types.ErrorType.USER,
+      severity: "error"
+    }));
+    return new import_errors.DextoValidationError(issues);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PreferenceError,
+  PreferenceErrorCode
+});

package/dist/preferences/errors.d.cts

@@ -0,0 +1,33 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.cjs';
+import { DextoValidationError } from '../errors/DextoValidationError.cjs';
+export { PreferenceErrorCode } from './error-codes.cjs';
+import { ZodError } from 'zod';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/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 '../agent/registry/error-codes.cjs';
+
+declare class PreferenceError {
+    static fileNotFound(preferencesPath: string): DextoRuntimeError<{
+        preferencesPath: string;
+    }>;
+    static fileReadError(preferencesPath: string, cause: string): DextoRuntimeError<{
+        preferencesPath: string;
+        cause: string;
+    }>;
+    static fileWriteError(preferencesPath: string, cause: string): DextoRuntimeError<{
+        preferencesPath: string;
+        cause: string;
+    }>;
+    static validationFailed(zodError: ZodError): DextoValidationError;
+}
+
+export { PreferenceError };

package/dist/preferences/errors.d.ts

@@ -0,0 +1,33 @@
+import { DextoRuntimeError } from '../errors/DextoRuntimeError.js';
+import { DextoValidationError } from '../errors/DextoValidationError.js';
+export { PreferenceErrorCode } from './error-codes.js';
+import { ZodError } from 'zod';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/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 '../agent/registry/error-codes.js';
+
+declare class PreferenceError {
+    static fileNotFound(preferencesPath: string): DextoRuntimeError<{
+        preferencesPath: string;
+    }>;
+    static fileReadError(preferencesPath: string, cause: string): DextoRuntimeError<{
+        preferencesPath: string;
+        cause: string;
+    }>;
+    static fileWriteError(preferencesPath: string, cause: string): DextoRuntimeError<{
+        preferencesPath: string;
+        cause: string;
+    }>;
+    static validationFailed(zodError: ZodError): DextoValidationError;
+}
+
+export { PreferenceError };

package/dist/preferences/errors.js

@@ -0,0 +1,50 @@
+import { DextoRuntimeError, DextoValidationError } from "../errors/index.js";
+import { ErrorScope, ErrorType } from "../errors/types.js";
+import { PreferenceErrorCode } from "./error-codes.js";
+import { PreferenceErrorCode as PreferenceErrorCode2 } from "./error-codes.js";
+class PreferenceError {
+  static fileNotFound(preferencesPath) {
+    return new DextoRuntimeError(
+      PreferenceErrorCode.FILE_NOT_FOUND,
+      ErrorScope.PREFERENCE,
+      ErrorType.USER,
+      `Preferences file not found: ${preferencesPath}`,
+      { preferencesPath },
+      "Run `dexto setup` to create preferences"
+    );
+  }
+  static fileReadError(preferencesPath, cause) {
+    return new DextoRuntimeError(
+      PreferenceErrorCode.FILE_READ_ERROR,
+      ErrorScope.PREFERENCE,
+      ErrorType.SYSTEM,
+      `Failed to read preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and ensure the file is not corrupted"
+    );
+  }
+  static fileWriteError(preferencesPath, cause) {
+    return new DextoRuntimeError(
+      PreferenceErrorCode.FILE_WRITE_ERROR,
+      ErrorScope.PREFERENCE,
+      ErrorType.SYSTEM,
+      `Failed to save preferences: ${cause}`,
+      { preferencesPath, cause },
+      "Check file permissions and available disk space"
+    );
+  }
+  static validationFailed(zodError) {
+    const issues = zodError.issues.map((issue) => ({
+      code: PreferenceErrorCode.VALIDATION_ERROR,
+      message: `${issue.path.join(".")}: ${issue.message}`,
+      scope: ErrorScope.PREFERENCE,
+      type: ErrorType.USER,
+      severity: "error"
+    }));
+    return new DextoValidationError(issues);
+  }
+}
+export {
+  PreferenceError,
+  PreferenceErrorCode2 as PreferenceErrorCode
+};

package/dist/preferences/index.cjs

@@ -0,0 +1,55 @@
+"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 preferences_exports = {};
+__export(preferences_exports, {
+  GlobalPreferencesSchema: () => import_schemas.GlobalPreferencesSchema,
+  PREFERENCES_FILE: () => import_constants.PREFERENCES_FILE,
+  PreferenceDefaultsSchema: () => import_schemas.PreferenceDefaultsSchema,
+  PreferenceError: () => import_errors.PreferenceError,
+  PreferenceErrorCode: () => import_errors.PreferenceErrorCode,
+  PreferenceLLMSchema: () => import_schemas.PreferenceLLMSchema,
+  PreferenceSetupSchema: () => import_schemas.PreferenceSetupSchema,
+  createInitialPreferences: () => import_loader.createInitialPreferences,
+  getGlobalPreferencesPath: () => import_loader.getGlobalPreferencesPath,
+  globalPreferencesExist: () => import_loader.globalPreferencesExist,
+  loadGlobalPreferences: () => import_loader.loadGlobalPreferences,
+  saveGlobalPreferences: () => import_loader.saveGlobalPreferences,
+  updateGlobalPreferences: () => import_loader.updateGlobalPreferences
+});
+module.exports = __toCommonJS(preferences_exports);
+var import_schemas = require("./schemas.js");
+var import_constants = require("./constants.js");
+var import_loader = require("./loader.js");
+var import_errors = require("./errors.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GlobalPreferencesSchema,
+  PREFERENCES_FILE,
+  PreferenceDefaultsSchema,
+  PreferenceError,
+  PreferenceErrorCode,
+  PreferenceLLMSchema,
+  PreferenceSetupSchema,
+  createInitialPreferences,
+  getGlobalPreferencesPath,
+  globalPreferencesExist,
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  updateGlobalPreferences
+});

package/dist/preferences/index.d.cts

@@ -0,0 +1,21 @@
+export { GlobalPreferences, GlobalPreferencesSchema, PreferenceDefaults, PreferenceDefaultsSchema, PreferenceLLM, PreferenceLLMSchema, PreferenceSetup, PreferenceSetupSchema } from './schemas.cjs';
+export { PREFERENCES_FILE } from './constants.cjs';
+export { createInitialPreferences, getGlobalPreferencesPath, globalPreferencesExist, loadGlobalPreferences, saveGlobalPreferences, updateGlobalPreferences } from './loader.cjs';
+export { PreferenceError } from './errors.cjs';
+export { PreferenceErrorCode } from './error-codes.cjs';
+import 'zod';
+import '../llm/types.cjs';
+import '../errors/DextoRuntimeError.cjs';
+import '../errors/DextoBaseError.cjs';
+import '../errors/types.cjs';
+import '../agent/error-codes.cjs';
+import '../config/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 '../agent/registry/error-codes.cjs';
+import '../errors/DextoValidationError.cjs';

package/dist/preferences/index.d.ts

@@ -0,0 +1,21 @@
+export { GlobalPreferences, GlobalPreferencesSchema, PreferenceDefaults, PreferenceDefaultsSchema, PreferenceLLM, PreferenceLLMSchema, PreferenceSetup, PreferenceSetupSchema } from './schemas.js';
+export { PREFERENCES_FILE } from './constants.js';
+export { createInitialPreferences, getGlobalPreferencesPath, globalPreferencesExist, loadGlobalPreferences, saveGlobalPreferences, updateGlobalPreferences } from './loader.js';
+export { PreferenceError } from './errors.js';
+export { PreferenceErrorCode } from './error-codes.js';
+import 'zod';
+import '../llm/types.js';
+import '../errors/DextoRuntimeError.js';
+import '../errors/DextoBaseError.js';
+import '../errors/types.js';
+import '../agent/error-codes.js';
+import '../config/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 '../agent/registry/error-codes.js';
+import '../errors/DextoValidationError.js';

package/dist/preferences/index.js

@@ -0,0 +1,31 @@
+import {
+  GlobalPreferencesSchema,
+  PreferenceLLMSchema,
+  PreferenceDefaultsSchema,
+  PreferenceSetupSchema
+} from "./schemas.js";
+import { PREFERENCES_FILE } from "./constants.js";
+import {
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  globalPreferencesExist,
+  getGlobalPreferencesPath,
+  createInitialPreferences,
+  updateGlobalPreferences
+} from "./loader.js";
+import { PreferenceError, PreferenceErrorCode } from "./errors.js";
+export {
+  GlobalPreferencesSchema,
+  PREFERENCES_FILE,
+  PreferenceDefaultsSchema,
+  PreferenceError,
+  PreferenceErrorCode,
+  PreferenceLLMSchema,
+  PreferenceSetupSchema,
+  createInitialPreferences,
+  getGlobalPreferencesPath,
+  globalPreferencesExist,
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  updateGlobalPreferences
+};

package/dist/preferences/loader.cjs

@@ -0,0 +1,136 @@
+"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 loader_exports = {};
+__export(loader_exports, {
+  createInitialPreferences: () => createInitialPreferences,
+  getGlobalPreferencesPath: () => getGlobalPreferencesPath,
+  globalPreferencesExist: () => globalPreferencesExist,
+  loadGlobalPreferences: () => loadGlobalPreferences,
+  saveGlobalPreferences: () => saveGlobalPreferences,
+  updateGlobalPreferences: () => updateGlobalPreferences
+});
+module.exports = __toCommonJS(loader_exports);
+var import_fs = require("fs");
+var import_fs2 = require("fs");
+var import_yaml = require("yaml");
+var import_path = require("../utils/path.cjs");
+var import_logger = require("../logger/index.cjs");
+var import_errors = require("../errors/index.cjs");
+var import_schemas = require("./schemas.js");
+var import_constants = require("./constants.js");
+var import_errors2 = require("./errors.js");
+async function loadGlobalPreferences() {
+  const preferencesPath = (0, import_path.getDextoGlobalPath)(import_constants.PREFERENCES_FILE);
+  if (!(0, import_fs.existsSync)(preferencesPath)) {
+    throw import_errors2.PreferenceError.fileNotFound(preferencesPath);
+  }
+  try {
+    const fileContent = await import_fs2.promises.readFile(preferencesPath, "utf-8");
+    const rawPreferences = (0, import_yaml.parse)(fileContent);
+    const validation = import_schemas.GlobalPreferencesSchema.safeParse(rawPreferences);
+    if (!validation.success) {
+      throw import_errors2.PreferenceError.validationFailed(validation.error);
+    }
+    import_logger.logger.debug(`Loaded global preferences from: ${preferencesPath}`);
+    return validation.data;
+  } catch (error) {
+    if (error instanceof import_errors.DextoValidationError || error instanceof import_errors.DextoRuntimeError) {
+      throw error;
+    }
+    throw import_errors2.PreferenceError.fileReadError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveGlobalPreferences(preferences) {
+  const preferencesPath = (0, import_path.getDextoGlobalPath)(import_constants.PREFERENCES_FILE);
+  const validation = import_schemas.GlobalPreferencesSchema.safeParse(preferences);
+  if (!validation.success) {
+    throw import_errors2.PreferenceError.validationFailed(validation.error);
+  }
+  try {
+    import_logger.logger.info(`Saving global preferences to: ${preferencesPath}`);
+    const dextoDir = (0, import_path.getDextoGlobalPath)("");
+    await import_fs2.promises.mkdir(dextoDir, { recursive: true });
+    const yamlContent = (0, import_yaml.stringify)(preferences, {
+      indent: 2,
+      lineWidth: 100,
+      minContentWidth: 20
+    });
+    await import_fs2.promises.writeFile(preferencesPath, yamlContent, "utf-8");
+    import_logger.logger.info(
+      `\u2713 Saved global preferences ${JSON.stringify(preferences)} to: ${preferencesPath}`
+    );
+  } catch (error) {
+    throw import_errors2.PreferenceError.fileWriteError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function globalPreferencesExist() {
+  const preferencesPath = (0, import_path.getDextoGlobalPath)(import_constants.PREFERENCES_FILE);
+  return (0, import_fs.existsSync)(preferencesPath);
+}
+function getGlobalPreferencesPath() {
+  return (0, import_path.getDextoGlobalPath)(import_constants.PREFERENCES_FILE);
+}
+function createInitialPreferences(provider, model, apiKeyVar, defaultAgent = "default-agent") {
+  return {
+    llm: {
+      provider,
+      model,
+      apiKey: `$${apiKeyVar}`
+    },
+    defaults: {
+      defaultAgent
+    },
+    setup: {
+      completed: true
+    }
+  };
+}
+async function updateGlobalPreferences(updates) {
+  const existing = await loadGlobalPreferences();
+  const merged = {
+    ...existing,
+    ...updates,
+    // LLM section requires complete replacement (high coherence - provider/model/apiKey must match)
+    llm: updates.llm || existing.llm,
+    // Defaults and setup sections allow partial updates (low coherence - independent fields)
+    defaults: updates.defaults ? { ...existing.defaults, ...updates.defaults } : existing.defaults,
+    setup: updates.setup ? { ...existing.setup, ...updates.setup } : existing.setup
+  };
+  const validation = import_schemas.GlobalPreferencesSchema.safeParse(merged);
+  if (!validation.success) {
+    throw import_errors2.PreferenceError.validationFailed(validation.error);
+  }
+  await saveGlobalPreferences(validation.data);
+  return validation.data;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createInitialPreferences,
+  getGlobalPreferencesPath,
+  globalPreferencesExist,
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  updateGlobalPreferences
+});

package/dist/preferences/loader.d.cts

@@ -0,0 +1,45 @@
+import { LLMProvider } from '../llm/types.cjs';
+import { GlobalPreferences } from './schemas.cjs';
+import 'zod';
+
+/**
+ * Load global preferences from ~/.dexto/preferences.yml
+ * @returns Global preferences object
+ * @throws DextoRuntimeError if file not found or corrupted
+ * @throws DextoValidationError if preferences are invalid
+ */
+declare function loadGlobalPreferences(): Promise<GlobalPreferences>;
+/**
+ * Save global preferences to ~/.dexto/preferences.yml
+ * @param preferences Validated preferences object
+ * @throws DextoRuntimeError if write fails
+ */
+declare function saveGlobalPreferences(preferences: GlobalPreferences): Promise<void>;
+/**
+ * Check if global preferences exist (for first-time detection)
+ * @returns true if preferences.yml exists
+ */
+declare function globalPreferencesExist(): boolean;
+/**
+ * Get global preferences file path
+ * @returns Absolute path to preferences.yml
+ */
+declare function getGlobalPreferencesPath(): string;
+/**
+ * Create initial preferences from setup data
+ * @param provider Selected LLM provider
+ * @param model Selected model
+ * @param apiKeyVar Environment variable name for API key
+ * @param defaultAgent Optional default agent name
+ */
+declare function createInitialPreferences(provider: LLMProvider, model: string, apiKeyVar: string, defaultAgent?: string): GlobalPreferences;
+/**
+ * Update specific preference sections
+ * @param updates Partial preference updates
+ * @returns Updated preferences object
+ * @throws DextoRuntimeError if load/save fails
+ * @throws DextoValidationError if merged preferences are invalid
+ */
+declare function updateGlobalPreferences(updates: Partial<GlobalPreferences>): Promise<GlobalPreferences>;
+
+export { createInitialPreferences, getGlobalPreferencesPath, globalPreferencesExist, loadGlobalPreferences, saveGlobalPreferences, updateGlobalPreferences };

package/dist/preferences/loader.d.ts

@@ -0,0 +1,45 @@
+import { LLMProvider } from '../llm/types.js';
+import { GlobalPreferences } from './schemas.js';
+import 'zod';
+
+/**
+ * Load global preferences from ~/.dexto/preferences.yml
+ * @returns Global preferences object
+ * @throws DextoRuntimeError if file not found or corrupted
+ * @throws DextoValidationError if preferences are invalid
+ */
+declare function loadGlobalPreferences(): Promise<GlobalPreferences>;
+/**
+ * Save global preferences to ~/.dexto/preferences.yml
+ * @param preferences Validated preferences object
+ * @throws DextoRuntimeError if write fails
+ */
+declare function saveGlobalPreferences(preferences: GlobalPreferences): Promise<void>;
+/**
+ * Check if global preferences exist (for first-time detection)
+ * @returns true if preferences.yml exists
+ */
+declare function globalPreferencesExist(): boolean;
+/**
+ * Get global preferences file path
+ * @returns Absolute path to preferences.yml
+ */
+declare function getGlobalPreferencesPath(): string;
+/**
+ * Create initial preferences from setup data
+ * @param provider Selected LLM provider
+ * @param model Selected model
+ * @param apiKeyVar Environment variable name for API key
+ * @param defaultAgent Optional default agent name
+ */
+declare function createInitialPreferences(provider: LLMProvider, model: string, apiKeyVar: string, defaultAgent?: string): GlobalPreferences;
+/**
+ * Update specific preference sections
+ * @param updates Partial preference updates
+ * @returns Updated preferences object
+ * @throws DextoRuntimeError if load/save fails
+ * @throws DextoValidationError if merged preferences are invalid
+ */
+declare function updateGlobalPreferences(updates: Partial<GlobalPreferences>): Promise<GlobalPreferences>;
+
+export { createInitialPreferences, getGlobalPreferencesPath, globalPreferencesExist, loadGlobalPreferences, saveGlobalPreferences, updateGlobalPreferences };