@dexto/core 1.2.4 → 1.2.6

package/dist/preferences/loader.js

@@ -1,110 +0,0 @@
-import "../chunk-C6A6W6XS.js";
-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 "../logger/index.js";
-import { DextoValidationError, DextoRuntimeError } from "../errors/index.js";
-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

@@ -1,75 +0,0 @@
-"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_registry = require("../llm/registry.cjs");
-var import_types = require("../llm/types.cjs");
-var import_result = require("../utils/result.cjs");
-var import_error_codes = require("./error-codes.js");
-var import_types2 = require("../errors/types.cjs");
-const PreferenceLLMSchema = import_zod.z.object({
-  provider: import_zod.z.enum(import_types.LLM_PROVIDERS).describe("LLM provider (openai, anthropic, google, etc.)"),
-  model: import_result.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_registry.isValidProviderModel)(data.provider, data.model)) {
-    const supportedModels = (0, import_registry.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: import_types2.ErrorScope.PREFERENCE,
-        type: import_types2.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

@@ -1,110 +0,0 @@
-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, {
-    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;
-    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-    model: 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: "mcp" | "cli" | "web" | "server" | "discord" | "telegram";
-}, {
-    defaultAgent: string;
-    defaultMode?: "mcp" | "cli" | "web" | "server" | "discord" | "telegram" | 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, {
-        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;
-        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-        model: string;
-    }>;
-    defaults: z.ZodObject<{
-        defaultAgent: z.ZodString;
-        defaultMode: z.ZodDefault<z.ZodEnum<["cli", "web", "server", "discord", "telegram", "mcp"]>>;
-    }, "strict", z.ZodTypeAny, {
-        defaultAgent: string;
-        defaultMode: "mcp" | "cli" | "web" | "server" | "discord" | "telegram";
-    }, {
-        defaultAgent: string;
-        defaultMode?: "mcp" | "cli" | "web" | "server" | "discord" | "telegram" | undefined;
-    }>;
-    setup: z.ZodDefault<z.ZodObject<{
-        completed: z.ZodDefault<z.ZodBoolean>;
-    }, "strict", z.ZodTypeAny, {
-        completed: boolean;
-    }, {
-        completed?: boolean | undefined;
-    }>>;
-}, "strict", z.ZodTypeAny, {
-    llm: {
-        apiKey: string;
-        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-        model: string;
-    };
-    defaults: {
-        defaultAgent: string;
-        defaultMode: "mcp" | "cli" | "web" | "server" | "discord" | "telegram";
-    };
-    setup: {
-        completed: boolean;
-    };
-}, {
-    llm: {
-        apiKey: string;
-        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
-        model: string;
-    };
-    defaults: {
-        defaultAgent: string;
-        defaultMode?: "mcp" | "cli" | "web" | "server" | "discord" | "telegram" | 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

@@ -1 +0,0 @@
-{"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

@@ -1,49 +0,0 @@
-import "../chunk-C6A6W6XS.js";
-import { z } from "zod";
-import { isValidProviderModel, getSupportedModels } from "../llm/registry.js";
-import { LLM_PROVIDERS } from "../llm/types.js";
-import { NonEmptyTrimmed } from "../utils/result.js";
-import { PreferenceErrorCode } from "./error-codes.js";
-import { ErrorScope, ErrorType } from "../errors/types.js";
-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: ErrorScope.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
-};