@dexto/agent-management 1.2.5

package/dist/preferences/loader.cjs

@@ -0,0 +1,138 @@
+"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.js");
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+var import_schemas = require("./schemas.js");
+var import_constants = require("./constants.js");
+var import_errors = require("./errors.js");
+async function loadGlobalPreferences() {
+  const preferencesPath = (0, import_path.getDextoGlobalPath)(import_constants.PREFERENCES_FILE);
+  if (!(0, import_fs.existsSync)(preferencesPath)) {
+    throw import_errors.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_errors.PreferenceError.validationFailed(validation.error);
+    }
+    import_core.logger.debug(`Loaded global preferences from: ${preferencesPath}`);
+    return validation.data;
+  } catch (error) {
+    if (error instanceof import_core2.DextoValidationError || error instanceof import_core2.DextoRuntimeError) {
+      throw error;
+    }
+    throw import_errors.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_errors.PreferenceError.validationFailed(validation.error);
+  }
+  try {
+    import_core.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_core.logger.info(
+      `\u2713 Saved global preferences ${JSON.stringify(preferences)} to: ${preferencesPath}`
+    );
+  } catch (error) {
+    throw import_errors.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,
+      defaultMode: "web"
+      // Default to web mode
+    },
+    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_errors.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.ts

@@ -0,0 +1,50 @@
+import type { LLMProvider } from '@dexto/core';
+import { type GlobalPreferences } from './schemas.js';
+/**
+ * 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
+ */
+export declare function loadGlobalPreferences(): Promise<GlobalPreferences>;
+/**
+ * Save global preferences to ~/.dexto/preferences.yml
+ * @param preferences Validated preferences object
+ * @throws DextoRuntimeError if write fails
+ */
+export declare function saveGlobalPreferences(preferences: GlobalPreferences): Promise<void>;
+/**
+ * Check if global preferences exist (for first-time detection)
+ * @returns true if preferences.yml exists
+ */
+export declare function globalPreferencesExist(): boolean;
+/**
+ * Get global preferences file path
+ * @returns Absolute path to preferences.yml
+ */
+export 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
+ */
+export declare function createInitialPreferences(provider: LLMProvider, model: string, apiKeyVar: string, defaultAgent?: string): GlobalPreferences;
+/**
+ * Updates type that allows partial nested objects
+ */
+export type GlobalPreferencesUpdates = {
+    llm?: GlobalPreferences['llm'];
+    defaults?: Partial<GlobalPreferences['defaults']>;
+    setup?: Partial<GlobalPreferences['setup']>;
+};
+/**
+ * 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
+ */
+export declare function updateGlobalPreferences(updates: GlobalPreferencesUpdates): Promise<GlobalPreferences>;
+//# sourceMappingURL=loader.d.ts.map

package/dist/preferences/loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.d.ts","sourceRoot":"","sources":["../../src/preferences/loader.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC/C,OAAO,EAA2B,KAAK,iBAAiB,EAAE,MAAM,cAAc,CAAC;AAI/E;;;;;GAKG;AACH,wBAAsB,qBAAqB,IAAI,OAAO,CAAC,iBAAiB,CAAC,CA+BxE;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,WAAW,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAkCzF;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAGhD;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,CAEjD;AAED;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CACpC,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,YAAY,GAAE,MAAwB,GACvC,iBAAiB,CAenB;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACnC,GAAG,CAAC,EAAE,iBAAiB,CAAC,KAAK,CAAC,CAAC;IAC/B,QAAQ,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC,CAAC;IAClD,KAAK,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC;CAC/C,CAAC;AAEF;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CACzC,OAAO,EAAE,wBAAwB,GAClC,OAAO,CAAC,iBAAiB,CAAC,CA2B5B"}

package/dist/preferences/loader.js

@@ -0,0 +1,109 @@
+import { existsSync } from "fs";
+import { promises as fs } from "fs";
+import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { getDextoGlobalPath } from "../utils/path.js";
+import { logger } from "@dexto/core";
+import { DextoValidationError, DextoRuntimeError } from "@dexto/core";
+import { GlobalPreferencesSchema } from "./schemas.js";
+import { PREFERENCES_FILE } from "./constants.js";
+import { PreferenceError } from "./errors.js";
+async function loadGlobalPreferences() {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  if (!existsSync(preferencesPath)) {
+    throw PreferenceError.fileNotFound(preferencesPath);
+  }
+  try {
+    const fileContent = await fs.readFile(preferencesPath, "utf-8");
+    const rawPreferences = parseYaml(fileContent);
+    const validation = GlobalPreferencesSchema.safeParse(rawPreferences);
+    if (!validation.success) {
+      throw PreferenceError.validationFailed(validation.error);
+    }
+    logger.debug(`Loaded global preferences from: ${preferencesPath}`);
+    return validation.data;
+  } catch (error) {
+    if (error instanceof DextoValidationError || error instanceof DextoRuntimeError) {
+      throw error;
+    }
+    throw PreferenceError.fileReadError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+async function saveGlobalPreferences(preferences) {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  const validation = GlobalPreferencesSchema.safeParse(preferences);
+  if (!validation.success) {
+    throw PreferenceError.validationFailed(validation.error);
+  }
+  try {
+    logger.info(`Saving global preferences to: ${preferencesPath}`);
+    const dextoDir = getDextoGlobalPath("");
+    await fs.mkdir(dextoDir, { recursive: true });
+    const yamlContent = stringifyYaml(preferences, {
+      indent: 2,
+      lineWidth: 100,
+      minContentWidth: 20
+    });
+    await fs.writeFile(preferencesPath, yamlContent, "utf-8");
+    logger.info(
+      `\u2713 Saved global preferences ${JSON.stringify(preferences)} to: ${preferencesPath}`
+    );
+  } catch (error) {
+    throw PreferenceError.fileWriteError(
+      preferencesPath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function globalPreferencesExist() {
+  const preferencesPath = getDextoGlobalPath(PREFERENCES_FILE);
+  return existsSync(preferencesPath);
+}
+function getGlobalPreferencesPath() {
+  return getDextoGlobalPath(PREFERENCES_FILE);
+}
+function createInitialPreferences(provider, model, apiKeyVar, defaultAgent = "default-agent") {
+  return {
+    llm: {
+      provider,
+      model,
+      apiKey: `$${apiKeyVar}`
+    },
+    defaults: {
+      defaultAgent,
+      defaultMode: "web"
+      // Default to web mode
+    },
+    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 = GlobalPreferencesSchema.safeParse(merged);
+  if (!validation.success) {
+    throw PreferenceError.validationFailed(validation.error);
+  }
+  await saveGlobalPreferences(validation.data);
+  return validation.data;
+}
+export {
+  createInitialPreferences,
+  getGlobalPreferencesPath,
+  globalPreferencesExist,
+  loadGlobalPreferences,
+  saveGlobalPreferences,
+  updateGlobalPreferences
+};

package/dist/preferences/schemas.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 schemas_exports = {};
+__export(schemas_exports, {
+  GlobalPreferencesSchema: () => GlobalPreferencesSchema,
+  PreferenceDefaultsSchema: () => PreferenceDefaultsSchema,
+  PreferenceLLMSchema: () => PreferenceLLMSchema,
+  PreferenceSetupSchema: () => PreferenceSetupSchema
+});
+module.exports = __toCommonJS(schemas_exports);
+var import_zod = require("zod");
+var import_core = require("@dexto/core");
+var import_core2 = require("@dexto/core");
+var import_core3 = require("@dexto/core");
+var import_error_codes = require("./error-codes.js");
+var import_core4 = require("@dexto/core");
+const PreferenceLLMSchema = import_zod.z.object({
+  provider: import_zod.z.enum(import_core2.LLM_PROVIDERS).describe("LLM provider (openai, anthropic, google, etc.)"),
+  model: import_core3.NonEmptyTrimmed.describe("Model name for the provider"),
+  apiKey: import_zod.z.string().regex(
+    /^\$[A-Z_][A-Z0-9_]*$/,
+    "Must be environment variable reference (e.g., $OPENAI_API_KEY)"
+  ).describe("Environment variable reference for API key")
+}).strict().superRefine((data, ctx) => {
+  if (!(0, import_core.isValidProviderModel)(data.provider, data.model)) {
+    const supportedModels = (0, import_core.getSupportedModels)(data.provider);
+    ctx.addIssue({
+      code: import_zod.z.ZodIssueCode.custom,
+      path: ["model"],
+      message: `Model '${data.model}' is not supported by provider '${data.provider}'. Supported models: ${supportedModels.join(", ")}`,
+      params: {
+        code: import_error_codes.PreferenceErrorCode.MODEL_INCOMPATIBLE,
+        scope: "preference",
+        type: import_core4.ErrorType.USER
+      }
+    });
+  }
+});
+const PreferenceDefaultsSchema = import_zod.z.object({
+  defaultAgent: import_zod.z.string().min(1).describe("Default agent name for global CLI usage (required)"),
+  defaultMode: import_zod.z.enum(["cli", "web", "server", "discord", "telegram", "mcp"]).default("web").describe("Default run mode when --mode flag is not specified (default: web)")
+}).strict();
+const PreferenceSetupSchema = import_zod.z.object({
+  completed: import_zod.z.boolean().default(false).describe("Whether initial setup has been completed")
+}).strict();
+const GlobalPreferencesSchema = import_zod.z.object({
+  llm: PreferenceLLMSchema.describe("LLM configuration preferences"),
+  defaults: PreferenceDefaultsSchema.describe("Default behavior preferences (required)"),
+  setup: PreferenceSetupSchema.default({ completed: false }).describe(
+    "Setup completion tracking"
+  )
+}).strict();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GlobalPreferencesSchema,
+  PreferenceDefaultsSchema,
+  PreferenceLLMSchema,
+  PreferenceSetupSchema
+});

package/dist/preferences/schemas.d.ts

@@ -0,0 +1,110 @@
+import { z } from 'zod';
+export declare const PreferenceLLMSchema: z.ZodEffects<z.ZodObject<{
+    provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>;
+    model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+    apiKey: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    model: string;
+    apiKey: string;
+}, {
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    model: string;
+    apiKey: string;
+}>, {
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    model: string;
+    apiKey: string;
+}, {
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    model: string;
+    apiKey: string;
+}>;
+export declare const PreferenceDefaultsSchema: z.ZodObject<{
+    defaultAgent: z.ZodString;
+    defaultMode: z.ZodDefault<z.ZodEnum<["cli", "web", "server", "discord", "telegram", "mcp"]>>;
+}, "strict", z.ZodTypeAny, {
+    defaultAgent: string;
+    defaultMode: "cli" | "web" | "server" | "discord" | "telegram" | "mcp";
+}, {
+    defaultAgent: string;
+    defaultMode?: "cli" | "web" | "server" | "discord" | "telegram" | "mcp" | undefined;
+}>;
+export declare const PreferenceSetupSchema: z.ZodObject<{
+    completed: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    completed: boolean;
+}, {
+    completed?: boolean | undefined;
+}>;
+export declare const GlobalPreferencesSchema: z.ZodObject<{
+    llm: z.ZodEffects<z.ZodObject<{
+        provider: z.ZodEnum<["openai", "openai-compatible", "anthropic", "google", "groq", "xai", "cohere"]>;
+        model: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
+        apiKey: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+        model: string;
+        apiKey: string;
+    }, {
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+        model: string;
+        apiKey: string;
+    }>, {
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+        model: string;
+        apiKey: string;
+    }, {
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+        model: string;
+        apiKey: string;
+    }>;
+    defaults: z.ZodObject<{
+        defaultAgent: z.ZodString;
+        defaultMode: z.ZodDefault<z.ZodEnum<["cli", "web", "server", "discord", "telegram", "mcp"]>>;
+    }, "strict", z.ZodTypeAny, {
+        defaultAgent: string;
+        defaultMode: "cli" | "web" | "server" | "discord" | "telegram" | "mcp";
+    }, {
+        defaultAgent: string;
+        defaultMode?: "cli" | "web" | "server" | "discord" | "telegram" | "mcp" | undefined;
+    }>;
+    setup: z.ZodDefault<z.ZodObject<{
+        completed: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        completed: boolean;
+    }, {
+        completed?: boolean | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    llm: {
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+        model: string;
+        apiKey: string;
+    };
+    defaults: {
+        defaultAgent: string;
+        defaultMode: "cli" | "web" | "server" | "discord" | "telegram" | "mcp";
+    };
+    setup: {
+        completed: boolean;
+    };
+}, {
+    llm: {
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+        model: string;
+        apiKey: string;
+    };
+    defaults: {
+        defaultAgent: string;
+        defaultMode?: "cli" | "web" | "server" | "discord" | "telegram" | "mcp" | undefined;
+    };
+    setup?: {
+        completed?: boolean | undefined;
+    } | undefined;
+}>;
+export type PreferenceLLM = z.output<typeof PreferenceLLMSchema>;
+export type PreferenceDefaults = z.output<typeof PreferenceDefaultsSchema>;
+export type PreferenceSetup = z.output<typeof PreferenceSetupSchema>;
+export type GlobalPreferences = z.output<typeof GlobalPreferencesSchema>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/preferences/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../src/preferences/schemas.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;EA6B1B,CAAC;AAEP,eAAO,MAAM,wBAAwB;;;;;;;;;EAYxB,CAAC;AAEd,eAAO,MAAM,qBAAqB;;;;;;EAIrB,CAAC;AAEd,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUvB,CAAC;AAGd,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,mBAAmB,CAAC,CAAC;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC3E,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACrE,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/preferences/schemas.js

@@ -0,0 +1,48 @@
+import { z } from "zod";
+import { isValidProviderModel, getSupportedModels } from "@dexto/core";
+import { LLM_PROVIDERS } from "@dexto/core";
+import { NonEmptyTrimmed } from "@dexto/core";
+import { PreferenceErrorCode } from "./error-codes.js";
+import { ErrorType } from "@dexto/core";
+const PreferenceLLMSchema = z.object({
+  provider: z.enum(LLM_PROVIDERS).describe("LLM provider (openai, anthropic, google, etc.)"),
+  model: NonEmptyTrimmed.describe("Model name for the provider"),
+  apiKey: z.string().regex(
+    /^\$[A-Z_][A-Z0-9_]*$/,
+    "Must be environment variable reference (e.g., $OPENAI_API_KEY)"
+  ).describe("Environment variable reference for API key")
+}).strict().superRefine((data, ctx) => {
+  if (!isValidProviderModel(data.provider, data.model)) {
+    const supportedModels = getSupportedModels(data.provider);
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ["model"],
+      message: `Model '${data.model}' is not supported by provider '${data.provider}'. Supported models: ${supportedModels.join(", ")}`,
+      params: {
+        code: PreferenceErrorCode.MODEL_INCOMPATIBLE,
+        scope: "preference",
+        type: ErrorType.USER
+      }
+    });
+  }
+});
+const PreferenceDefaultsSchema = z.object({
+  defaultAgent: z.string().min(1).describe("Default agent name for global CLI usage (required)"),
+  defaultMode: z.enum(["cli", "web", "server", "discord", "telegram", "mcp"]).default("web").describe("Default run mode when --mode flag is not specified (default: web)")
+}).strict();
+const PreferenceSetupSchema = z.object({
+  completed: z.boolean().default(false).describe("Whether initial setup has been completed")
+}).strict();
+const GlobalPreferencesSchema = z.object({
+  llm: PreferenceLLMSchema.describe("LLM configuration preferences"),
+  defaults: PreferenceDefaultsSchema.describe("Default behavior preferences (required)"),
+  setup: PreferenceSetupSchema.default({ completed: false }).describe(
+    "Setup completion tracking"
+  )
+}).strict();
+export {
+  GlobalPreferencesSchema,
+  PreferenceDefaultsSchema,
+  PreferenceLLMSchema,
+  PreferenceSetupSchema
+};

package/dist/registry/error-codes.cjs

@@ -0,0 +1,44 @@
+"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, {
+  RegistryErrorCode: () => RegistryErrorCode
+});
+module.exports = __toCommonJS(error_codes_exports);
+var RegistryErrorCode = /* @__PURE__ */ ((RegistryErrorCode2) => {
+  RegistryErrorCode2["AGENT_NOT_FOUND"] = "registry_agent_not_found";
+  RegistryErrorCode2["AGENT_INVALID_ENTRY"] = "registry_agent_invalid_entry";
+  RegistryErrorCode2["AGENT_ALREADY_EXISTS"] = "registry_agent_already_exists";
+  RegistryErrorCode2["INSTALLATION_FAILED"] = "registry_installation_failed";
+  RegistryErrorCode2["INSTALLATION_VALIDATION_FAILED"] = "registry_installation_validation_failed";
+  RegistryErrorCode2["REGISTRY_NOT_FOUND"] = "registry_file_not_found";
+  RegistryErrorCode2["REGISTRY_PARSE_ERROR"] = "registry_parse_error";
+  RegistryErrorCode2["REGISTRY_WRITE_ERROR"] = "registry_write_error";
+  RegistryErrorCode2["CONFIG_NOT_FOUND"] = "registry_config_not_found";
+  RegistryErrorCode2["MAIN_CONFIG_MISSING"] = "registry_main_config_missing";
+  RegistryErrorCode2["AGENT_NOT_INSTALLED"] = "registry_agent_not_installed";
+  RegistryErrorCode2["AGENT_PROTECTED"] = "registry_agent_protected";
+  RegistryErrorCode2["UNINSTALLATION_FAILED"] = "registry_uninstallation_failed";
+  RegistryErrorCode2["AGENT_NOT_INSTALLED_AUTO_INSTALL_DISABLED"] = "registry_agent_not_installed_auto_install_disabled";
+  return RegistryErrorCode2;
+})(RegistryErrorCode || {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegistryErrorCode
+});

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

@@ -0,0 +1,21 @@
+/**
+ * Registry-specific error codes
+ * Includes agent resolution, installation, and registry management errors
+ */
+export declare enum RegistryErrorCode {
+    AGENT_NOT_FOUND = "registry_agent_not_found",
+    AGENT_INVALID_ENTRY = "registry_agent_invalid_entry",
+    AGENT_ALREADY_EXISTS = "registry_agent_already_exists",
+    INSTALLATION_FAILED = "registry_installation_failed",
+    INSTALLATION_VALIDATION_FAILED = "registry_installation_validation_failed",
+    REGISTRY_NOT_FOUND = "registry_file_not_found",
+    REGISTRY_PARSE_ERROR = "registry_parse_error",
+    REGISTRY_WRITE_ERROR = "registry_write_error",
+    CONFIG_NOT_FOUND = "registry_config_not_found",
+    MAIN_CONFIG_MISSING = "registry_main_config_missing",
+    AGENT_NOT_INSTALLED = "registry_agent_not_installed",
+    AGENT_PROTECTED = "registry_agent_protected",
+    UNINSTALLATION_FAILED = "registry_uninstallation_failed",
+    AGENT_NOT_INSTALLED_AUTO_INSTALL_DISABLED = "registry_agent_not_installed_auto_install_disabled"
+}
+//# sourceMappingURL=error-codes.d.ts.map

package/dist/registry/error-codes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-codes.d.ts","sourceRoot":"","sources":["../../src/registry/error-codes.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,oBAAY,iBAAiB;IAEzB,eAAe,6BAA6B;IAC5C,mBAAmB,iCAAiC;IACpD,oBAAoB,kCAAkC;IAGtD,mBAAmB,iCAAiC;IACpD,8BAA8B,4CAA4C;IAG1E,kBAAkB,4BAA4B;IAC9C,oBAAoB,yBAAyB;IAC7C,oBAAoB,yBAAyB;IAG7C,gBAAgB,8BAA8B;IAC9C,mBAAmB,iCAAiC;IAGpD,mBAAmB,iCAAiC;IACpD,eAAe,6BAA6B;IAC5C,qBAAqB,mCAAmC;IAGxD,yCAAyC,uDAAuD;CACnG"}

package/dist/registry/error-codes.js

@@ -0,0 +1,20 @@
+var RegistryErrorCode = /* @__PURE__ */ ((RegistryErrorCode2) => {
+  RegistryErrorCode2["AGENT_NOT_FOUND"] = "registry_agent_not_found";
+  RegistryErrorCode2["AGENT_INVALID_ENTRY"] = "registry_agent_invalid_entry";
+  RegistryErrorCode2["AGENT_ALREADY_EXISTS"] = "registry_agent_already_exists";
+  RegistryErrorCode2["INSTALLATION_FAILED"] = "registry_installation_failed";
+  RegistryErrorCode2["INSTALLATION_VALIDATION_FAILED"] = "registry_installation_validation_failed";
+  RegistryErrorCode2["REGISTRY_NOT_FOUND"] = "registry_file_not_found";
+  RegistryErrorCode2["REGISTRY_PARSE_ERROR"] = "registry_parse_error";
+  RegistryErrorCode2["REGISTRY_WRITE_ERROR"] = "registry_write_error";
+  RegistryErrorCode2["CONFIG_NOT_FOUND"] = "registry_config_not_found";
+  RegistryErrorCode2["MAIN_CONFIG_MISSING"] = "registry_main_config_missing";
+  RegistryErrorCode2["AGENT_NOT_INSTALLED"] = "registry_agent_not_installed";
+  RegistryErrorCode2["AGENT_PROTECTED"] = "registry_agent_protected";
+  RegistryErrorCode2["UNINSTALLATION_FAILED"] = "registry_uninstallation_failed";
+  RegistryErrorCode2["AGENT_NOT_INSTALLED_AUTO_INSTALL_DISABLED"] = "registry_agent_not_installed_auto_install_disabled";
+  return RegistryErrorCode2;
+})(RegistryErrorCode || {});
+export {
+  RegistryErrorCode
+};