@dexto/core 1.2.3 → 1.2.5

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
-};

package/dist/utils/api-key-store.cjs

@@ -1,56 +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 api_key_store_exports = {};
-__export(api_key_store_exports, {
-  getProviderKeyStatus: () => getProviderKeyStatus,
-  listProviderKeyStatus: () => listProviderKeyStatus,
-  saveProviderApiKey: () => saveProviderApiKey
-});
-module.exports = __toCommonJS(api_key_store_exports);
-var import_types = require("../llm/types.js");
-var import_api_key_resolver = require("./api-key-resolver.js");
-var import_env = require("./env.js");
-var import_path = require("./path.js");
-async function saveProviderApiKey(provider, apiKey, startPath) {
-  if (!provider) throw new Error("provider is required");
-  if (!apiKey || !apiKey.trim()) throw new Error("apiKey is required");
-  const envVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(provider);
-  const targetEnvPath = (0, import_path.getDextoEnvPath)(startPath);
-  await (0, import_env.updateEnvFile)(targetEnvPath, { [envVar]: apiKey });
-  process.env[envVar] = apiKey;
-  return { envVar, targetEnvPath };
-}
-function getProviderKeyStatus(provider) {
-  const envVar = (0, import_api_key_resolver.getPrimaryApiKeyEnvVar)(provider);
-  const key = (0, import_api_key_resolver.resolveApiKeyForProvider)(provider);
-  return { hasApiKey: Boolean(key && key.trim()), envVar };
-}
-function listProviderKeyStatus() {
-  const result = {};
-  for (const p of import_types.LLM_PROVIDERS) {
-    result[p] = getProviderKeyStatus(p);
-  }
-  return result;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getProviderKeyStatus,
-  listProviderKeyStatus,
-  saveProviderApiKey
-});

package/dist/utils/api-key-store.d.ts

@@ -1,24 +0,0 @@
-import type { LLMProvider } from '../llm/types.js';
-/**
- * Save provider API key to the correct .env and make it immediately available in-process.
- * Never returns the key; only metadata for callers to display.
- */
-export declare function saveProviderApiKey(provider: LLMProvider, apiKey: string, startPath?: string): Promise<{
-    envVar: string;
-    targetEnvPath: string;
-}>;
-/**
- * Get key presence and primary env var name for a provider.
- */
-export declare function getProviderKeyStatus(provider: LLMProvider): {
-    hasApiKey: boolean;
-    envVar: string;
-};
-/**
- * List key presence across all known providers.
- */
-export declare function listProviderKeyStatus(): Record<string, {
-    hasApiKey: boolean;
-    envVar: string;
-}>;
-//# sourceMappingURL=api-key-store.d.ts.map

package/dist/utils/api-key-store.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"api-key-store.d.ts","sourceRoot":"","sources":["../../src/utils/api-key-store.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAMnD;;;GAGG;AACH,wBAAsB,kBAAkB,CACpC,QAAQ,EAAE,WAAW,EACrB,MAAM,EAAE,MAAM,EACd,SAAS,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAE,CAAC,CAapD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,WAAW,GAAG;IACzD,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAClB,CAIA;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,MAAM,CAAC,MAAM,EAAE;IAAE,SAAS,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAM9F"}

package/dist/utils/api-key-store.js

@@ -1,31 +0,0 @@
-import "../chunk-C6A6W6XS.js";
-import { LLM_PROVIDERS } from "../llm/types.js";
-import { getPrimaryApiKeyEnvVar, resolveApiKeyForProvider } from "./api-key-resolver.js";
-import { updateEnvFile } from "./env.js";
-import { getDextoEnvPath } from "./path.js";
-async function saveProviderApiKey(provider, apiKey, startPath) {
-  if (!provider) throw new Error("provider is required");
-  if (!apiKey || !apiKey.trim()) throw new Error("apiKey is required");
-  const envVar = getPrimaryApiKeyEnvVar(provider);
-  const targetEnvPath = getDextoEnvPath(startPath);
-  await updateEnvFile(targetEnvPath, { [envVar]: apiKey });
-  process.env[envVar] = apiKey;
-  return { envVar, targetEnvPath };
-}
-function getProviderKeyStatus(provider) {
-  const envVar = getPrimaryApiKeyEnvVar(provider);
-  const key = resolveApiKeyForProvider(provider);
-  return { hasApiKey: Boolean(key && key.trim()), envVar };
-}
-function listProviderKeyStatus() {
-  const result = {};
-  for (const p of LLM_PROVIDERS) {
-    result[p] = getProviderKeyStatus(p);
-  }
-  return result;
-}
-export {
-  getProviderKeyStatus,
-  listProviderKeyStatus,
-  saveProviderApiKey
-};

package/dist/utils/env.cjs

@@ -1,154 +0,0 @@
-"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 env_exports = {};
-__export(env_exports, {
-  applyLayeredEnvironmentLoading: () => applyLayeredEnvironmentLoading,
-  loadEnvironmentVariables: () => loadEnvironmentVariables,
-  updateEnvFile: () => updateEnvFile
-});
-module.exports = __toCommonJS(env_exports);
-var path = __toESM(require("path"), 1);
-var import_os = require("os");
-var import_fs = require("fs");
-var import_dotenv = __toESM(require("dotenv"), 1);
-var import_execution_context = require("./execution-context.js");
-var import_path = require("./path.js");
-async function loadEnvironmentVariables(startPath = process.cwd()) {
-  const context = (0, import_execution_context.getExecutionContext)(startPath);
-  const env = {};
-  const globalEnvPath = path.join((0, import_os.homedir)(), ".dexto", ".env");
-  try {
-    const globalResult = import_dotenv.default.config({ path: globalEnvPath, processEnv: {} });
-    if (globalResult.parsed) {
-      Object.assign(env, globalResult.parsed);
-    }
-  } catch {
-  }
-  if (context === "dexto-source" || context === "dexto-project") {
-    const projectEnvPath = (0, import_path.getDextoEnvPath)(startPath);
-    try {
-      const projectResult = import_dotenv.default.config({ path: projectEnvPath, processEnv: {} });
-      if (projectResult.parsed) {
-        Object.assign(env, projectResult.parsed);
-      }
-    } catch {
-    }
-  }
-  for (const [key, value] of Object.entries(process.env)) {
-    if (value !== void 0 && value !== "") {
-      env[key] = value;
-    }
-  }
-  return env;
-}
-async function applyLayeredEnvironmentLoading(startPath = process.cwd()) {
-  await (0, import_path.ensureDextoGlobalDirectory)();
-  const layeredEnv = await loadEnvironmentVariables(startPath);
-  Object.assign(process.env, layeredEnv);
-}
-async function updateEnvFile(envFilePath, updates) {
-  const dextoEnvKeys = [
-    "OPENAI_API_KEY",
-    "ANTHROPIC_API_KEY",
-    "GOOGLE_GENERATIVE_AI_API_KEY",
-    "GROQ_API_KEY",
-    "COHERE_API_KEY",
-    "XAI_API_KEY",
-    "DEXTO_LOG_LEVEL"
-  ];
-  await import_fs.promises.mkdir(path.dirname(envFilePath), { recursive: true });
-  let envLines = [];
-  try {
-    const existingEnv = await import_fs.promises.readFile(envFilePath, "utf8");
-    envLines = existingEnv.split("\n");
-  } catch {
-  }
-  const currentValues = {};
-  envLines.forEach((line) => {
-    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
-    if (match && match[1] && match[2] !== void 0 && dextoEnvKeys.includes(match[1])) {
-      currentValues[match[1]] = match[2];
-    }
-  });
-  const updatedValues = {
-    OPENAI_API_KEY: updates.OPENAI_API_KEY ?? currentValues.OPENAI_API_KEY ?? "",
-    ANTHROPIC_API_KEY: updates.ANTHROPIC_API_KEY ?? currentValues.ANTHROPIC_API_KEY ?? "",
-    GOOGLE_GENERATIVE_AI_API_KEY: updates.GOOGLE_GENERATIVE_AI_API_KEY ?? currentValues.GOOGLE_GENERATIVE_AI_API_KEY ?? "",
-    GROQ_API_KEY: updates.GROQ_API_KEY ?? currentValues.GROQ_API_KEY ?? "",
-    COHERE_API_KEY: updates.COHERE_API_KEY ?? currentValues.COHERE_API_KEY ?? "",
-    XAI_API_KEY: updates.XAI_API_KEY ?? currentValues.XAI_API_KEY ?? "",
-    DEXTO_LOG_LEVEL: updates.DEXTO_LOG_LEVEL ?? currentValues.DEXTO_LOG_LEVEL ?? "info"
-  };
-  const sectionHeader = "## Dexto env variables";
-  const headerIndex = envLines.findIndex((line) => line.trim() === sectionHeader);
-  let contentLines;
-  if (headerIndex !== -1) {
-    const beforeSection = envLines.slice(0, headerIndex);
-    let sectionEnd = headerIndex + 1;
-    while (sectionEnd < envLines.length && envLines[sectionEnd]?.trim() !== "") {
-      sectionEnd++;
-    }
-    if (sectionEnd < envLines.length && envLines[sectionEnd]?.trim() === "") {
-      sectionEnd++;
-    }
-    const afterSection = envLines.slice(sectionEnd);
-    contentLines = [...beforeSection, ...afterSection];
-  } else {
-    contentLines = envLines;
-  }
-  const existingEnvVars = {};
-  contentLines.forEach((line) => {
-    const match = line.match(/^([A-Z0-9_]+)=(.*)$/);
-    if (match && match[1] && match[2] !== void 0 && dextoEnvKeys.includes(match[1])) {
-      existingEnvVars[match[1]] = match[2];
-    }
-  });
-  if (contentLines.length > 0) {
-    if (contentLines[contentLines.length - 1]?.trim() !== "") {
-      contentLines.push("");
-    }
-  } else {
-    contentLines.push("");
-  }
-  contentLines.push(sectionHeader);
-  for (const key of dextoEnvKeys) {
-    if (key in existingEnvVars && !(key in updates)) {
-      continue;
-    }
-    contentLines.push(`${key}=${updatedValues[key]}`);
-  }
-  contentLines.push("");
-  await import_fs.promises.writeFile(envFilePath, contentLines.join("\n"), "utf8");
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyLayeredEnvironmentLoading,
-  loadEnvironmentVariables,
-  updateEnvFile
-});

package/dist/utils/env.d.ts

@@ -1,28 +0,0 @@
-/**
- * Multi-layer environment variable loading with context awareness.
- * Loads environment variables in priority order:
- * 1. Shell environment (highest priority)
- * 2. Project .env (if in dexto project)
- * 3. Global ~/.dexto/.env (fallback)
- *
- * @param startPath Starting directory for project detection
- * @returns Combined environment variables object
- */
-export declare function loadEnvironmentVariables(startPath?: string): Promise<Record<string, string>>;
-/**
- * Apply layered environment loading to process.env.
- * This replaces the simple dotenv.config() with multi-layer loading.
- * Should be called at CLI startup before any schema validation.
- *
- * @param startPath Starting directory for project detection
- */
-export declare function applyLayeredEnvironmentLoading(startPath?: string): Promise<void>;
-/**
- * Core logic to update an .env file with Dexto environment variables.
- * This is the shared implementation used by both project and interactive env file updates.
- *
- * @param envFilePath - Absolute path to the .env file to update
- * @param updates - Object containing environment variable updates
- */
-export declare function updateEnvFile(envFilePath: string, updates: Record<string, string>): Promise<void>;
-//# sourceMappingURL=env.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/utils/env.ts"],"names":[],"mappings":"AAOA;;;;;;;;;GASG;AACH,wBAAsB,wBAAwB,CAC1C,SAAS,GAAE,MAAsB,GAClC,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAuCjC;AAED;;;;;;GAMG;AACH,wBAAsB,8BAA8B,CAChD,SAAS,GAAE,MAAsB,GAClC,OAAO,CAAC,IAAI,CAAC,CAOf;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CAC/B,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAChC,OAAO,CAAC,IAAI,CAAC,CAiHf"}