dexto 1.0.1 → 1.1.0

package/dist/src/app/chunk-O5YHNFMH.js

@@ -1,435 +0,0 @@
-// src/core/utils/path.ts
-import * as path from "path";
-import { existsSync, readFileSync } from "fs";
-import { homedir } from "os";
-import { createRequire } from "module";
-
-// src/core/error/index.ts
-var ConfigurationError = class extends Error {
-  /**
-   * Creates an instance of ConfigurationError.
-   * @param message - A human-readable description of the error.
-   * @param configPath - Optional. The path to the configuration file related to the error.
-   */
-  constructor(message, configPath) {
-    super(message);
-    this.configPath = configPath;
-    this.name = this.constructor.name;
-  }
-};
-var ConfigFileNotFoundError = class extends ConfigurationError {
-  /**
-   * Creates an instance of ConfigFileNotFoundError.
-   * @param configPath - The path to the configuration file that was not found.
-   */
-  constructor(configPath) {
-    super(`Configuration file not found: ${configPath}`, configPath);
-  }
-};
-var ConfigFileReadError = class extends ConfigurationError {
-  /**
-   * Creates an instance of ConfigFileReadError.
-   * @param configPath - The path to the configuration file that could not be read.
-   * @param cause - A string describing the underlying reason for the read failure (e.g., "Permission denied").
-   */
-  constructor(configPath, cause) {
-    super(`Failed to read configuration file: ${cause}`, configPath);
-  }
-};
-var ConfigParseError = class extends ConfigurationError {
-  /**
-   * Creates an instance of ConfigParseError.
-   * @param configPath - The path to the configuration file that failed to parse.
-   * @param cause - A string detailing the parsing error (e.g., "YAMLException: bad indentation").
-   */
-  constructor(configPath, cause) {
-    super(`Failed to parse YAML configuration: ${cause}`, configPath);
-  }
-};
-var ConfigEnvVarError = class extends ConfigurationError {
-  /**
-   * Creates an instance of ConfigEnvVarError.
-   * @param configPath - The path to the configuration file where the environment variable issue occurred.
-   * @param envVar - The name of the environment variable that caused the error.
-   * @param cause - Optional. A string describing the specific reason for the expansion failure (e.g., "not defined").
-   */
-  constructor(configPath, envVar, cause) {
-    const message = cause ? `Failed to expand environment variable '${envVar}': ${cause}` : `Environment variable '${envVar}' is required but not set`;
-    super(message, configPath);
-    this.envVar = envVar;
-  }
-};
-
-// src/core/utils/path.ts
-var DEFAULT_CONFIG_PATH = "agents/agent.yml";
-function walkUpDirectories(startPath, predicate) {
-  let currentPath = path.resolve(startPath);
-  const rootPath = path.parse(currentPath).root;
-  while (currentPath !== rootPath) {
-    if (predicate(currentPath)) {
-      return currentPath;
-    }
-    currentPath = path.dirname(currentPath);
-  }
-  return null;
-}
-function hasDextoDependency(dirPath) {
-  const packageJsonPath = path.join(dirPath, "package.json");
-  try {
-    const pkg = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    if (pkg.name === "dexto") {
-      return true;
-    }
-    const allDeps = {
-      ...pkg.dependencies,
-      ...pkg.devDependencies,
-      ...pkg.peerDependencies
-    };
-    return "dexto" in allDeps;
-  } catch {
-    return false;
-  }
-}
-function getDextoProjectRoot(startPath = process.cwd()) {
-  return walkUpDirectories(startPath, hasDextoDependency);
-}
-function getDextoPath(type, filename, startPath) {
-  const projectRoot = getDextoProjectRoot(startPath);
-  let basePath;
-  if (projectRoot) {
-    basePath = path.join(projectRoot, ".dexto", type);
-  } else {
-    basePath = path.join(homedir(), ".dexto", type);
-  }
-  return filename ? path.join(basePath, filename) : basePath;
-}
-function resolveConfigPath(configPath, startPath) {
-  if (configPath) {
-    return path.resolve(configPath);
-  }
-  const projectRoot = getDextoProjectRoot(startPath);
-  if (projectRoot) {
-    const configPaths = [
-      path.join(projectRoot, "agents", "agent.yml"),
-      // Standard
-      path.join(projectRoot, "src", "agents", "agent.yml"),
-      // Common
-      path.join(projectRoot, "src", "dexto", "agents", "agent.yml"),
-      // Test app structure
-      path.join(projectRoot, ".dexto", "agent.yml"),
-      // Hidden
-      path.join(projectRoot, "agent.yml")
-      // Root
-    ];
-    for (const configPath2 of configPaths) {
-      if (existsSync(configPath2)) {
-        return configPath2;
-      }
-    }
-    throw new ConfigFileNotFoundError(
-      `No agent.yml found in project. Searched: ${configPaths.join(", ")}`
-    );
-  } else {
-    try {
-      const bundledConfigPath = resolveBundledScript("agents/agent.yml");
-      if (existsSync(bundledConfigPath)) {
-        return bundledConfigPath;
-      }
-    } catch {
-    }
-    throw new ConfigFileNotFoundError(
-      "Global CLI: No bundled config found and no explicit config provided"
-    );
-  }
-}
-function findPackageRoot(startPath = process.cwd()) {
-  return walkUpDirectories(startPath, (dirPath) => {
-    const pkgPath = path.join(dirPath, "package.json");
-    return existsSync(pkgPath);
-  });
-}
-function resolveBundledScript(scriptPath) {
-  try {
-    const require2 = createRequire(import.meta.url);
-    const packageJsonPath = require2.resolve("dexto/package.json");
-    const packageRoot = path.dirname(packageJsonPath);
-    return path.resolve(packageRoot, scriptPath);
-  } catch {
-    const packageRoot = findPackageRoot();
-    if (!packageRoot) {
-      throw new Error(`Cannot resolve bundled script: ${scriptPath}`);
-    }
-    return path.resolve(packageRoot, scriptPath);
-  }
-}
-
-// src/core/logger/logger.ts
-import * as winston from "winston";
-import chalk from "chalk";
-import boxen from "boxen";
-import * as fs from "fs";
-import * as path2 from "path";
-var logLevels = {
-  error: 0,
-  warn: 1,
-  info: 2,
-  http: 3,
-  verbose: 4,
-  debug: 5,
-  silly: 6
-};
-var consoleFormat = winston.format.printf(({ level, message, timestamp, color }) => {
-  const levelColorMap = {
-    error: chalk.red,
-    warn: chalk.yellow,
-    info: chalk.blue,
-    http: chalk.cyan,
-    verbose: chalk.magenta,
-    debug: chalk.gray,
-    silly: chalk.gray.dim
-  };
-  const colorize = levelColorMap[level] || chalk.white;
-  const formattedMessage = color && typeof color === "string" && chalk[color] ? chalk[color](message) : message;
-  return `${chalk.dim(timestamp)} ${colorize(level.toUpperCase())}: ${formattedMessage}`;
-});
-var SHOULD_REDACT = process.env.REDACT_SECRETS !== "false";
-var SENSITIVE_KEYS = ["apiKey", "password", "secret", "token"];
-var MASK_REGEX = new RegExp(
-  `(${SENSITIVE_KEYS.join("|")})(["']?\\s*[:=]\\s*)(["'])?.*?\\3`,
-  "gi"
-);
-var maskFormat = winston.format((info) => {
-  if (SHOULD_REDACT && typeof info.message === "string") {
-    info.message = info.message.replace(MASK_REGEX, "$1$2$3[REDACTED]$3");
-  }
-  return info;
-});
-var getDefaultLogLevel = () => {
-  const envLevel = process.env.DEXTO_LOG_LEVEL;
-  if (envLevel && Object.keys(logLevels).includes(envLevel.toLowerCase())) {
-    return envLevel.toLowerCase();
-  }
-  return "info";
-};
-var Logger = class {
-  logger;
-  isSilent = false;
-  logFilePath = null;
-  logToConsole = false;
-  constructor(options = {}) {
-    this.isSilent = options.silent || false;
-    this.initializeTransports(options);
-    this.logger = winston.createLogger({
-      levels: logLevels,
-      level: options.level || getDefaultLogLevel(),
-      silent: options.silent || false,
-      format: winston.format.combine(
-        winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-        maskFormat(),
-        winston.format.errors({ stack: true }),
-        winston.format.splat(),
-        winston.format.json()
-      ),
-      transports: this.createTransports(options)
-    });
-  }
-  initializeTransports(options) {
-    const logToConsole = options.logToConsole ?? process.env.DEXTO_LOG_TO_CONSOLE === "true";
-    this.logToConsole = logToConsole;
-    if (options.customLogPath) {
-      this.logFilePath = options.customLogPath;
-    } else {
-      this.logFilePath = getDextoPath("logs", "dexto.log");
-    }
-  }
-  createTransports(_options) {
-    const transports2 = [];
-    if (this.logToConsole) {
-      transports2.push(
-        new winston.transports.Console({
-          format: winston.format.combine(
-            winston.format.timestamp({ format: "HH:mm:ss" }),
-            maskFormat(),
-            consoleFormat
-          )
-        })
-      );
-    }
-    try {
-      if (this.logFilePath) {
-        const logDir = path2.dirname(this.logFilePath);
-        fs.mkdirSync(logDir, { recursive: true });
-        transports2.push(
-          new winston.transports.File({
-            filename: this.logFilePath,
-            format: winston.format.combine(
-              winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),
-              maskFormat(),
-              winston.format.errors({ stack: true }),
-              winston.format.json()
-            ),
-            // Add daily rotation
-            maxsize: 10 * 1024 * 1024,
-            // 10MB
-            maxFiles: 7,
-            // Keep 7 files
-            tailable: true
-          })
-        );
-      }
-    } catch (error) {
-      console.error(`Failed to initialize file logging: ${error}. Falling back to console.`);
-      if (!this.logToConsole) {
-        this.logToConsole = true;
-        transports2.push(
-          new winston.transports.Console({
-            format: winston.format.combine(
-              winston.format.timestamp({ format: "HH:mm:ss" }),
-              maskFormat(),
-              consoleFormat
-            )
-          })
-        );
-      }
-    }
-    return transports2;
-  }
-  // General logging methods with optional color parameter
-  error(message, meta, color) {
-    this.logger.error(message, { ...meta, color });
-  }
-  warn(message, meta, color) {
-    this.logger.warn(message, { ...meta, color });
-  }
-  info(message, meta, color) {
-    this.logger.info(message, { ...meta, color });
-  }
-  http(message, meta, color) {
-    this.logger.http(message, { ...meta, color });
-  }
-  verbose(message, meta, color) {
-    this.logger.verbose(message, { ...meta, color });
-  }
-  debug(message, meta, color) {
-    const formattedMessage = typeof message === "string" ? message : JSON.stringify(message, null, 2);
-    this.logger.debug(formattedMessage, { ...meta, color });
-  }
-  silly(message, meta, color) {
-    this.logger.silly(message, { ...meta, color });
-  }
-  // Display AI response in a box
-  displayAIResponse(response) {
-    if (this.isSilent) return;
-    if (response.content) {
-      console.log(
-        boxen(chalk.white(response.content), {
-          padding: 1,
-          borderColor: "yellow",
-          title: "\u{1F916} AI Response",
-          titleAlignment: "center"
-        })
-      );
-    } else {
-      console.log(chalk.yellow("AI is thinking..."));
-    }
-  }
-  // Tool-related logging
-  toolCall(toolName, args) {
-    if (this.isSilent) return;
-    console.log(
-      boxen(
-        `${chalk.cyan("Tool Call")}: ${chalk.yellow(toolName)}
-${chalk.dim("Arguments")}:
-${chalk.white(JSON.stringify(args, null, 2))}`,
-        { padding: 1, borderColor: "blue", title: "\u{1F527} Tool Call", titleAlignment: "center" }
-      )
-    );
-  }
-  toolResult(result) {
-    if (this.isSilent) return;
-    let displayText = "";
-    let isError = false;
-    let borderColor = "green";
-    let title = "\u2705 Tool Result";
-    if (result?.error || result?.isError) {
-      isError = true;
-      borderColor = "yellow";
-      title = "\u26A0\uFE0F Tool Result (Error)";
-    }
-    if (result?.content && Array.isArray(result.content)) {
-      result.content.forEach((item) => {
-        if (item.type === "text") {
-          displayText += item.text;
-        } else if (item.type === "image" && item.url) {
-          displayText += `[Image URL: ${item.url}]`;
-        } else if (item.type === "image") {
-          displayText += `[Image Data: ${item.mimeType || "unknown type"}]`;
-        } else if (item.type === "markdown") {
-          displayText += item.markdown;
-        } else {
-          displayText += `[Unsupported content type: ${item.type}]`;
-        }
-        displayText += "\n";
-      });
-    } else if (result?.message) {
-      displayText = result.message;
-      isError = true;
-      borderColor = "red";
-      title = "\u274C Tool Error";
-    } else if (typeof result === "string") {
-      displayText = result;
-    } else {
-      try {
-        displayText = JSON.stringify(result, null, 2);
-      } catch {
-        displayText = `[Unparseable result: ${typeof result}]`;
-      }
-    }
-    if (!displayText || displayText.trim() === "") {
-      displayText = "[Empty result]";
-    }
-    const textColor = isError ? chalk.yellow : chalk.green;
-    console.log(
-      boxen(textColor(displayText), {
-        padding: 1,
-        borderColor,
-        title,
-        titleAlignment: "center"
-      })
-    );
-  }
-  // Configuration
-  setLevel(level) {
-    if (Object.keys(logLevels).includes(level.toLowerCase())) {
-      this.logger.level = level.toLowerCase();
-      if (!this.isSilent) {
-        console.log(`Log level set to: ${level}`);
-      }
-    } else {
-      this.error(`Invalid log level: ${level}. Using current level: ${this.logger.level}`);
-    }
-  }
-  // Get the current log file path
-  getLogFilePath() {
-    return this.logFilePath;
-  }
-  // Get current log level
-  getLevel() {
-    return this.logger.level;
-  }
-};
-var logger = new Logger();
-
-export {
-  ConfigurationError,
-  ConfigFileNotFoundError,
-  ConfigFileReadError,
-  ConfigParseError,
-  ConfigEnvVarError,
-  DEFAULT_CONFIG_PATH,
-  getDextoPath,
-  resolveConfigPath,
-  findPackageRoot,
-  resolveBundledScript,
-  logger
-};

package/dist/src/app/interactive-api-key-setup-V3GAACLN.js

@@ -1,269 +0,0 @@
-import {
-  getPrimaryApiKeyEnvVar,
-  updateDextoConfigFile,
-  updateEnvFile
-} from "./chunk-M4OZIDPC.js";
-import {
-  DEFAULT_CONFIG_PATH,
-  logger,
-  resolveConfigPath
-} from "./chunk-O5YHNFMH.js";
-
-// src/app/cli/utils/interactive-api-key-setup.ts
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-async function interactiveApiKeySetup() {
-  try {
-    p.intro(chalk.cyan("\u{1F511} API Key Setup"));
-    p.note(
-      `Dexto needs an API key to work with AI models. You can:
-
-\u2022 ${chalk.green("Google Gemini")} - Free tier available (15 requests/minute)
-\u2022 ${chalk.blue("OpenAI")} - Most popular, requires payment
-\u2022 ${chalk.magenta("Anthropic")} - High quality models, requires payment
-\u2022 ${chalk.yellow("Groq")} - Fast inference, free tier available
-
-Don't have an API key? Get a free one from Google AI Studio!`,
-      chalk.bold("Choose your AI provider")
-    );
-    const action = await p.select({
-      message: "What would you like to do?",
-      options: [
-        {
-          value: "setup",
-          label: "Set up an API key now",
-          hint: "Interactive setup (recommended)"
-        },
-        {
-          value: "manual",
-          label: "Set up manually later",
-          hint: "Get instructions for manual setup"
-        },
-        {
-          value: "exit",
-          label: "Exit",
-          hint: "Quit Dexto for now"
-        }
-      ]
-    });
-    if (action === "exit") {
-      p.cancel("Setup cancelled. Run dexto again when you have an API key!");
-      return { success: false, skipSetup: true };
-    }
-    if (action === "manual") {
-      showManualSetupInstructions();
-      return { success: false, skipSetup: true };
-    }
-    const provider = await p.select({
-      message: "Select your AI provider",
-      options: [
-        {
-          value: "google",
-          label: "Google Gemini",
-          hint: "\u{1F193} Free tier available - get key from aistudio.google.com"
-        },
-        {
-          value: "openai",
-          label: "OpenAI",
-          hint: "\u{1F4B0} Requires payment - get key from platform.openai.com"
-        },
-        {
-          value: "anthropic",
-          label: "Anthropic Claude",
-          hint: "\u{1F4B0} Requires payment - get key from console.anthropic.com"
-        },
-        {
-          value: "groq",
-          label: "Groq",
-          hint: "\u{1F193} Free tier available - get key from console.groq.com"
-        }
-      ]
-    });
-    showProviderInstructions(provider);
-    const apiKey = await p.text({
-      message: `Enter your ${getProviderDisplayName(provider)} API key`,
-      placeholder: getApiKeyPlaceholder(provider),
-      validate: (value) => {
-        if (!value || value.trim().length === 0) {
-          return "API key is required";
-        }
-        if (!isValidApiKeyFormat(value.trim(), provider)) {
-          return `Invalid ${getProviderDisplayName(provider)} API key format`;
-        }
-        return void 0;
-      }
-    });
-    if (p.isCancel(apiKey)) {
-      p.cancel("Setup cancelled");
-      return { success: false };
-    }
-    const spinner2 = p.spinner();
-    spinner2.start("Saving API key and updating configuration...");
-    try {
-      await updateEnvFile(process.cwd(), provider, apiKey.trim());
-      try {
-        const configPath = resolveConfigPath(DEFAULT_CONFIG_PATH);
-        await updateDextoConfigFile(configPath, provider);
-        spinner2.stop("Configuration updated successfully! \u2728");
-      } catch (configError) {
-        spinner2.stop("API key saved, but config update failed");
-        logger.debug(`Failed to update agent config: ${configError}`);
-        p.note(
-          `API key saved successfully, but automatic config update failed.
-
-To use ${getProviderDisplayName(provider)}, you may need to:
-1. Edit your agent.yml file
-2. Update the llm.provider to "${provider}"
-3. Update the llm.apiKey to "$${getPrimaryApiKeyEnvVar(provider)}"`,
-          chalk.yellow("Manual config update needed")
-        );
-      }
-      p.outro(
-        chalk.green("\u{1F389} Setup complete!") + `
-
-Your ${getProviderDisplayName(provider)} API key has been saved to .env
-Dexto is now configured to use ${getProviderDisplayName(provider)}.`
-      );
-      return { success: true, provider };
-    } catch (error) {
-      spinner2.stop("Failed to save API key");
-      logger.error(`Failed to update .env file: ${error}`);
-      p.note(
-        `Manual setup required:
-
-1. Create a .env file in your project root
-2. Add this line: ${getPrimaryApiKeyEnvVar(provider)}=${apiKey}
-3. Update your agent.yml llm.provider to "${provider}"
-4. Update your agent.yml llm.apiKey to "$${getPrimaryApiKeyEnvVar(provider)}"
-5. Run dexto again`,
-        chalk.yellow("Save this API key manually")
-      );
-      return { success: false, provider };
-    }
-  } catch (error) {
-    if (p.isCancel(error)) {
-      p.cancel("Setup cancelled");
-      return { success: false };
-    }
-    throw error;
-  }
-}
-function showManualSetupInstructions() {
-  const instructions = [
-    `${chalk.bold("1. Get an API key:")}`,
-    `   \u2022 ${chalk.green("Google Gemini (Free)")}:  https://aistudio.google.com/apikey`,
-    `   \u2022 ${chalk.blue("OpenAI")}:           https://platform.openai.com/api-keys`,
-    `   \u2022 ${chalk.magenta("Anthropic")}:        https://console.anthropic.com/keys`,
-    `   \u2022 ${chalk.yellow("Groq (Free)")}:      https://console.groq.com/keys`,
-    ``,
-    `${chalk.bold("2. Create a .env file in your project:")}`,
-    `   echo "GOOGLE_GENERATIVE_AI_API_KEY=your_key_here" > .env`,
-    `   # OR for other providers:`,
-    `   # OPENAI_API_KEY=your_key_here`,
-    `   # ANTHROPIC_API_KEY=your_key_here`,
-    `   # GROQ_API_KEY=your_key_here`,
-    ``,
-    `${chalk.bold("3. Run dexto again:")}`,
-    `   npx dexto`,
-    ``,
-    `${chalk.dim("\u{1F4A1} Tip: Start with Google Gemini for a free experience!")}`
-  ].join("\n");
-  p.note(instructions, chalk.bold("Manual Setup Instructions"));
-}
-function showProviderInstructions(provider) {
-  const instructions = getProviderInstructions(provider);
-  if (instructions) {
-    p.note(instructions.content, instructions.title);
-  }
-}
-function getProviderInstructions(provider) {
-  switch (provider) {
-    case "google":
-      return {
-        title: chalk.green("Google Gemini - Free API Key"),
-        content: `1. Visit: ${chalk.cyan("https://aistudio.google.com/apikey")}
-2. Sign in with your Google account
-3. Click "Create API Key"
-4. Copy the key (starts with "AIza...")
-
-${chalk.dim("\u2728 Free tier: 15 requests/minute, 1500 requests/day")}`
-      };
-    case "openai":
-      return {
-        title: chalk.blue("OpenAI API Key"),
-        content: `1. Visit: ${chalk.cyan("https://platform.openai.com/api-keys")}
-2. Sign in to your OpenAI account
-3. Click "Create new secret key"
-4. Copy the key (starts with "sk-...")
-
-${chalk.dim("\u{1F4B0} Requires payment - $5 minimum credit")}`
-      };
-    case "anthropic":
-      return {
-        title: chalk.magenta("Anthropic API Key"),
-        content: `1. Visit: ${chalk.cyan("https://console.anthropic.com/keys")}
-2. Sign in to your Anthropic account
-3. Click "Create Key"
-4. Copy the key (starts with "sk-ant-...")
-
-${chalk.dim("\u{1F4B0} Requires payment - $5 minimum credit")}`
-      };
-    case "groq":
-      return {
-        title: chalk.yellow("Groq API Key"),
-        content: `1. Visit: ${chalk.cyan("https://console.groq.com/keys")}
-2. Sign in with your account
-3. Click "Create API Key"
-4. Copy the key (starts with "gsk_...")
-
-${chalk.dim("\u{1F193} Free tier: 30 requests/minute")}`
-      };
-    default:
-      return null;
-  }
-}
-function getProviderDisplayName(provider) {
-  switch (provider) {
-    case "google":
-      return "Google Gemini";
-    case "openai":
-      return "OpenAI";
-    case "anthropic":
-      return "Anthropic";
-    case "groq":
-      return "Groq";
-    default:
-      return provider;
-  }
-}
-function getApiKeyPlaceholder(provider) {
-  switch (provider) {
-    case "google":
-      return "AIza...";
-    case "openai":
-      return "sk-...";
-    case "anthropic":
-      return "sk-ant-...";
-    case "groq":
-      return "gsk_...";
-    default:
-      return "your-api-key";
-  }
-}
-function isValidApiKeyFormat(apiKey, provider) {
-  switch (provider) {
-    case "google":
-      return apiKey.startsWith("AIza") && apiKey.length > 20;
-    case "openai":
-      return apiKey.startsWith("sk-") && apiKey.length > 40;
-    case "anthropic":
-      return apiKey.startsWith("sk-ant-") && apiKey.length > 40;
-    case "groq":
-      return apiKey.startsWith("gsk_") && apiKey.length > 40;
-    default:
-      return apiKey.length > 10;
-  }
-}
-export {
-  interactiveApiKeySetup
-};