@dexto/core 1.1.4 → 1.1.6

package/dist/preferences/loader.js

@@ -0,0 +1,107 @@
+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
+    },
+    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,74 @@
+"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)")
+}).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.cts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+
+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;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}>, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}>;
+declare const PreferenceDefaultsSchema: z.ZodObject<{
+    defaultAgent: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    defaultAgent: string;
+}, {
+    defaultAgent: string;
+}>;
+declare const PreferenceSetupSchema: z.ZodObject<{
+    completed: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    completed: boolean;
+}, {
+    completed?: boolean | undefined;
+}>;
+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;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }, {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }>, {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }, {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }>;
+    defaults: z.ZodObject<{
+        defaultAgent: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        defaultAgent: string;
+    }, {
+        defaultAgent: string;
+    }>;
+    setup: z.ZodDefault<z.ZodObject<{
+        completed: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        completed: boolean;
+    }, {
+        completed?: boolean | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    llm: {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    };
+    defaults: {
+        defaultAgent: string;
+    };
+    setup: {
+        completed: boolean;
+    };
+}, {
+    llm: {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    };
+    defaults: {
+        defaultAgent: string;
+    };
+    setup?: {
+        completed?: boolean | undefined;
+    } | undefined;
+}>;
+type PreferenceLLM = z.output<typeof PreferenceLLMSchema>;
+type PreferenceDefaults = z.output<typeof PreferenceDefaultsSchema>;
+type PreferenceSetup = z.output<typeof PreferenceSetupSchema>;
+type GlobalPreferences = z.output<typeof GlobalPreferencesSchema>;
+
+export { type GlobalPreferences, GlobalPreferencesSchema, type PreferenceDefaults, PreferenceDefaultsSchema, type PreferenceLLM, PreferenceLLMSchema, type PreferenceSetup, PreferenceSetupSchema };

package/dist/preferences/schemas.d.ts

@@ -0,0 +1,104 @@
+import { z } from 'zod';
+
+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;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}>, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}, {
+    apiKey: string;
+    model: string;
+    provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+}>;
+declare const PreferenceDefaultsSchema: z.ZodObject<{
+    defaultAgent: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    defaultAgent: string;
+}, {
+    defaultAgent: string;
+}>;
+declare const PreferenceSetupSchema: z.ZodObject<{
+    completed: z.ZodDefault<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    completed: boolean;
+}, {
+    completed?: boolean | undefined;
+}>;
+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;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }, {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }>, {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }, {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    }>;
+    defaults: z.ZodObject<{
+        defaultAgent: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        defaultAgent: string;
+    }, {
+        defaultAgent: string;
+    }>;
+    setup: z.ZodDefault<z.ZodObject<{
+        completed: z.ZodDefault<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        completed: boolean;
+    }, {
+        completed?: boolean | undefined;
+    }>>;
+}, "strict", z.ZodTypeAny, {
+    llm: {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    };
+    defaults: {
+        defaultAgent: string;
+    };
+    setup: {
+        completed: boolean;
+    };
+}, {
+    llm: {
+        apiKey: string;
+        model: string;
+        provider: "openai" | "openai-compatible" | "anthropic" | "google" | "groq" | "xai" | "cohere";
+    };
+    defaults: {
+        defaultAgent: string;
+    };
+    setup?: {
+        completed?: boolean | undefined;
+    } | undefined;
+}>;
+type PreferenceLLM = z.output<typeof PreferenceLLMSchema>;
+type PreferenceDefaults = z.output<typeof PreferenceDefaultsSchema>;
+type PreferenceSetup = z.output<typeof PreferenceSetupSchema>;
+type GlobalPreferences = z.output<typeof GlobalPreferencesSchema>;
+
+export { type GlobalPreferences, GlobalPreferencesSchema, type PreferenceDefaults, PreferenceDefaultsSchema, type PreferenceLLM, PreferenceLLMSchema, type PreferenceSetup, PreferenceSetupSchema };

package/dist/preferences/schemas.js

@@ -0,0 +1,47 @@
+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)")
+}).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/search/index.cjs

@@ -0,0 +1,28 @@
+"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 search_exports = {};
+__export(search_exports, {
+  SearchService: () => import_search_service.SearchService
+});
+module.exports = __toCommonJS(search_exports);
+var import_search_service = require("./search-service.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SearchService
+});

package/dist/search/index.d.cts

@@ -0,0 +1,5 @@
+export { SearchService } from './search-service.cjs';
+export { SearchOptions, SearchResponse, SearchResult, SessionSearchResponse, SessionSearchResult } from './types.cjs';
+import '../storage/backend/database-backend.cjs';
+import '../context/types.cjs';
+import '../llm/types.cjs';

package/dist/search/index.d.ts

@@ -0,0 +1,5 @@
+export { SearchService } from './search-service.js';
+export { SearchOptions, SearchResponse, SearchResult, SessionSearchResponse, SessionSearchResult } from './types.js';
+import '../storage/backend/database-backend.js';
+import '../context/types.js';
+import '../llm/types.js';

package/dist/search/index.js

@@ -0,0 +1,4 @@
+import { SearchService } from "./search-service.js";
+export {
+  SearchService
+};