deepagentsdk 0.9.2

package/src/cli/theme.ts

@@ -0,0 +1,205 @@
+/**
+ * Theme constants for the Ink CLI.
+ * Colors, emoji, and styling values.
+ */
+
+/**
+ * Color palette for the CLI.
+ * Uses chalk-compatible color names.
+ */
+export const colors = {
+  // Primary colors
+  primary: "cyan",
+  secondary: "magenta",
+  accent: "yellow",
+
+  // Status colors
+  success: "green",
+  error: "red",
+  warning: "yellow",
+  info: "blue",
+
+  // Text colors
+  muted: "gray",
+  highlight: "white",
+
+  // Semantic colors
+  tool: "magenta",
+  file: "blue",
+  user: "cyan",
+  agent: "green",
+} as const;
+
+/**
+ * Status emoji for todo items and events.
+ */
+export const emoji = {
+  // Todo statuses
+  pending: "⏳",
+  in_progress: "🔄",
+  completed: "✅",
+  cancelled: "❌",
+
+  // UI elements
+  robot: "🤖",
+  thinking: "💭",
+  tool: "🔧",
+  file: "📁",
+  edit: "✏️",
+  todo: "📋",
+  done: "🎉",
+  error: "💥",
+  warning: "⚠️",
+  info: "ℹ️",
+  user: "👤",
+  subagent: "🤝",
+  key: "🔑",
+  model: "🧠",
+} as const;
+
+/**
+ * Box border styles for different UI elements.
+ */
+export const borders = {
+  panel: "round",
+  preview: "single",
+  alert: "double",
+} as const;
+
+/**
+ * Slash commands configuration.
+ */
+export interface SlashCommand {
+  command: string;
+  aliases: string[];
+  description: string;
+}
+
+export const SLASH_COMMANDS: SlashCommand[] = [
+  {
+    command: "/todos",
+    aliases: ["/t", "/todo"],
+    description: "Show current todo list",
+  },
+  {
+    command: "/files",
+    aliases: ["/f", "/file"],
+    description: "Show files in working directory",
+  },
+  {
+    command: "/read",
+    aliases: ["/r"],
+    description: "Read a file (usage: /read <path>)",
+  },
+  {
+    command: "/apikey",
+    aliases: ["/key", "/api"],
+    description: "Manage API keys (interactive)",
+  },
+  {
+    command: "/model",
+    aliases: [],
+    description: "Show available models or change model (usage: /model [model-name])",
+  },
+  {
+    command: "/features",
+    aliases: ["/feat"],
+    description: "Show enabled features (caching, eviction, summarization)",
+  },
+  {
+    command: "/tokens",
+    aliases: ["/tok"],
+    description: "Show estimated token count for conversation",
+  },
+  {
+    command: "/cache",
+    aliases: [],
+    description: "Toggle prompt caching (usage: /cache on|off)",
+  },
+  {
+    command: "/eviction",
+    aliases: ["/evict"],
+    description: "Toggle tool result eviction (usage: /eviction on|off)",
+  },
+  {
+    command: "/summarize",
+    aliases: ["/sum"],
+    description: "Toggle auto-summarization (usage: /summarize on|off)",
+  },
+  {
+    command: "/approve",
+    aliases: [],
+    description: "Toggle auto-approve mode for tool executions",
+  },
+  {
+    command: "/clear",
+    aliases: ["/c"],
+    description: "Clear chat history",
+  },
+  {
+    command: "/sessions",
+    aliases: ["/session-list"],
+    description: "List saved sessions",
+  },
+  {
+    command: "/session",
+    aliases: [],
+    description: "Session management (usage: /session clear)",
+  },
+  {
+    command: "/help",
+    aliases: ["/h", "/?"],
+    description: "Show help",
+  },
+  {
+    command: "/quit",
+    aliases: ["/q", "/exit"],
+    description: "Exit the CLI",
+  },
+];
+
+/**
+ * Filter commands by prefix.
+ */
+export function filterCommands(prefix?: string): SlashCommand[] {
+  if (!prefix) {
+    return SLASH_COMMANDS;
+  }
+
+  const normalizedPrefix = prefix.startsWith("/") ? prefix : `/${prefix}`;
+
+  return SLASH_COMMANDS.filter((cmd) => {
+    if (cmd.command.toLowerCase().startsWith(normalizedPrefix.toLowerCase())) {
+      return true;
+    }
+    return cmd.aliases.some((alias) =>
+      alias.toLowerCase().startsWith(normalizedPrefix.toLowerCase())
+    );
+  });
+}
+
+/**
+ * Parse a slash command from input.
+ */
+export function parseCommand(input: string): {
+  isCommand: boolean;
+  command?: string;
+  args?: string;
+} {
+  const trimmed = input.trim();
+
+  if (!trimmed.startsWith("/")) {
+    return { isCommand: false };
+  }
+
+  const parts = trimmed.slice(1).split(/\s+/);
+  const command = parts[0]?.toLowerCase();
+  const args = parts.slice(1).join(" ");
+
+  return {
+    isCommand: true,
+    command,
+    args: args || undefined,
+  };
+}
+

package/src/cli/utils/model-list.ts

@@ -0,0 +1,365 @@
+/**
+ * Utility to detect available API keys and fetch models from provider APIs.
+ */
+
+export interface AvailableModel {
+  id: string;
+  name: string;
+  provider: "anthropic" | "openai";
+  description?: string;
+  createdAt?: string;
+}
+
+export interface FetchModelsResult {
+  models: AvailableModel[];
+  error?: string;
+}
+
+// ============================================================================
+// Cache Implementation
+// ============================================================================
+
+interface CacheEntry {
+  models: AvailableModel[];
+  timestamp: number;
+  apiKeyHash: string;
+}
+
+const modelCache: {
+  anthropic?: CacheEntry;
+  openai?: CacheEntry;
+} = {};
+
+// Cache TTL: 24 hours in milliseconds
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
+/**
+ * Simple hash function for API key to detect changes.
+ */
+function hashApiKey(key: string | undefined): string {
+  if (!key) return "";
+  // Just use first 10 and last 4 chars as a simple fingerprint
+  return `${key.substring(0, 10)}...${key.substring(key.length - 4)}`;
+}
+
+/**
+ * Check if cache is valid for a provider.
+ */
+function isCacheValid(provider: "anthropic" | "openai"): boolean {
+  const entry = modelCache[provider];
+  if (!entry) return false;
+
+  const now = Date.now();
+  if (now - entry.timestamp > CACHE_TTL_MS) return false;
+
+  // Check if API key changed
+  const currentKeyHash =
+    provider === "anthropic"
+      ? hashApiKey(process.env.ANTHROPIC_API_KEY)
+      : hashApiKey(process.env.OPENAI_API_KEY);
+
+  return entry.apiKeyHash === currentKeyHash;
+}
+
+/**
+ * Get cached models for a provider.
+ */
+function getCachedModels(provider: "anthropic" | "openai"): AvailableModel[] | null {
+  if (isCacheValid(provider)) {
+    return modelCache[provider]!.models;
+  }
+  return null;
+}
+
+/**
+ * Set cached models for a provider.
+ */
+function setCachedModels(provider: "anthropic" | "openai", models: AvailableModel[]): void {
+  const apiKeyHash =
+    provider === "anthropic"
+      ? hashApiKey(process.env.ANTHROPIC_API_KEY)
+      : hashApiKey(process.env.OPENAI_API_KEY);
+
+  modelCache[provider] = {
+    models,
+    timestamp: Date.now(),
+    apiKeyHash,
+  };
+}
+
+/**
+ * Clear cache for a specific provider or all providers.
+ */
+export function clearModelCache(provider?: "anthropic" | "openai"): void {
+  if (provider) {
+    delete modelCache[provider];
+  } else {
+    delete modelCache.anthropic;
+    delete modelCache.openai;
+  }
+}
+
+// ============================================================================
+// Provider Detection
+// ============================================================================
+
+/**
+ * Detect which API keys are available in the environment.
+ */
+export function detectAvailableProviders(): {
+  anthropic: boolean;
+  openai: boolean;
+} {
+  return {
+    anthropic: !!process.env.ANTHROPIC_API_KEY,
+    openai: !!process.env.OPENAI_API_KEY,
+  };
+}
+
+// ============================================================================
+// Anthropic API
+// ============================================================================
+
+interface AnthropicModelInfo {
+  id: string;
+  display_name: string;
+  created_at: string;
+  type: string;
+}
+
+interface AnthropicModelsResponse {
+  data: AnthropicModelInfo[];
+  has_more: boolean;
+  first_id: string;
+  last_id: string;
+}
+
+/**
+ * Fetch available models from Anthropic API.
+ * Returns empty array if no API key is set.
+ */
+export async function fetchAnthropicModels(): Promise<FetchModelsResult> {
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    return { models: [], error: "No Anthropic API key configured" };
+  }
+
+  // Check cache first
+  const cached = getCachedModels("anthropic");
+  if (cached) {
+    return { models: cached };
+  }
+
+  try {
+    const response = await fetch("https://api.anthropic.com/v1/models?limit=100", {
+      method: "GET",
+      headers: {
+        "X-Api-Key": apiKey,
+        "anthropic-version": "2023-06-01",
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 401) {
+        return { models: [], error: "Invalid Anthropic API key" };
+      }
+      return { models: [], error: `Anthropic API error: ${response.status} ${errorText}` };
+    }
+
+    const data = (await response.json()) as AnthropicModelsResponse;
+
+    const models: AvailableModel[] = data.data.map((model) => ({
+      id: `anthropic/${model.id}`,
+      name: model.id,
+      provider: "anthropic" as const,
+      description: model.display_name,
+      createdAt: model.created_at,
+    }));
+
+    // Sort by created_at descending (newest first)
+    models.sort((a, b) => {
+      if (!a.createdAt || !b.createdAt) return 0;
+      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+    });
+
+    // Cache the results
+    setCachedModels("anthropic", models);
+
+    return { models };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { models: [], error: `Failed to fetch Anthropic models: ${message}` };
+  }
+}
+
+// ============================================================================
+// OpenAI API
+// ============================================================================
+
+interface OpenAIModelInfo {
+  id: string;
+  object: string;
+  created: number;
+  owned_by: string;
+}
+
+interface OpenAIModelsResponse {
+  object: string;
+  data: OpenAIModelInfo[];
+}
+
+/**
+ * Fetch available models from OpenAI API.
+ * Returns empty array if no API key is set.
+ */
+export async function fetchOpenAIModels(): Promise<FetchModelsResult> {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    return { models: [], error: "No OpenAI API key configured" };
+  }
+
+  // Check cache first
+  const cached = getCachedModels("openai");
+  if (cached) {
+    return { models: cached };
+  }
+
+  try {
+    const response = await fetch("https://api.openai.com/v1/models", {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${apiKey}`,
+      },
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 401) {
+        return { models: [], error: "Invalid OpenAI API key" };
+      }
+      return { models: [], error: `OpenAI API error: ${response.status} ${errorText}` };
+    }
+
+    const data = (await response.json()) as OpenAIModelsResponse;
+
+    // Filter to only include chat models (gpt-*)
+    const chatModels = data.data.filter(
+      (model) =>
+        model.id.startsWith("gpt-") ||
+        model.id.startsWith("o1") ||
+        model.id.startsWith("o3") ||
+        model.id.includes("chatgpt")
+    );
+
+    const models: AvailableModel[] = chatModels.map((model) => ({
+      id: `openai/${model.id}`,
+      name: model.id,
+      provider: "openai" as const,
+      description: getOpenAIModelDescription(model.id),
+      createdAt: new Date(model.created * 1000).toISOString(),
+    }));
+
+    // Sort by created descending (newest first)
+    models.sort((a, b) => {
+      if (!a.createdAt || !b.createdAt) return 0;
+      return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+    });
+
+    // Cache the results
+    setCachedModels("openai", models);
+
+    return { models };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { models: [], error: `Failed to fetch OpenAI models: ${message}` };
+  }
+}
+
+/**
+ * Generate a description for OpenAI models based on their ID.
+ */
+function getOpenAIModelDescription(modelId: string): string {
+  if (modelId.includes("gpt-4o-mini")) return "Fast and affordable GPT-4 variant";
+  if (modelId.includes("gpt-4o")) return "Latest GPT-4 optimized model";
+  if (modelId.includes("gpt-4-turbo")) return "GPT-4 Turbo";
+  if (modelId.includes("gpt-4")) return "GPT-4";
+  if (modelId.includes("gpt-3.5-turbo")) return "Fast and affordable";
+  if (modelId.startsWith("o1")) return "OpenAI o1 reasoning model";
+  if (modelId.startsWith("o3")) return "OpenAI o3 reasoning model";
+  return "";
+}
+
+// ============================================================================
+// Combined Functions
+// ============================================================================
+
+export interface GetModelsResult {
+  models: AvailableModel[];
+  errors: { provider: string; error: string }[];
+  loading: boolean;
+}
+
+/**
+ * Get list of available models from all configured providers.
+ * Only fetches from providers that have API keys configured.
+ */
+export async function getAvailableModels(): Promise<GetModelsResult> {
+  const providers = detectAvailableProviders();
+  const allModels: AvailableModel[] = [];
+  const errors: { provider: string; error: string }[] = [];
+
+  // Fetch from both providers in parallel
+  const promises: Promise<void>[] = [];
+
+  if (providers.anthropic) {
+    promises.push(
+      fetchAnthropicModels().then((result) => {
+        allModels.push(...result.models);
+        if (result.error) {
+          errors.push({ provider: "Anthropic", error: result.error });
+        }
+      })
+    );
+  }
+
+  if (providers.openai) {
+    promises.push(
+      fetchOpenAIModels().then((result) => {
+        allModels.push(...result.models);
+        if (result.error) {
+          errors.push({ provider: "OpenAI", error: result.error });
+        }
+      })
+    );
+  }
+
+  await Promise.all(promises);
+
+  return { models: allModels, errors, loading: false };
+}
+
+/**
+ * Get models grouped by provider.
+ */
+export async function getModelsByProvider(): Promise<{
+  anthropic?: AvailableModel[];
+  openai?: AvailableModel[];
+  errors: { provider: string; error: string }[];
+}> {
+  const result = await getAvailableModels();
+  const grouped: {
+    anthropic?: AvailableModel[];
+    openai?: AvailableModel[];
+    errors: { provider: string; error: string }[];
+  } = { errors: result.errors };
+
+  for (const model of result.models) {
+    if (!grouped[model.provider]) {
+      grouped[model.provider] = [];
+    }
+    grouped[model.provider]!.push(model);
+  }
+
+  return grouped;
+}

package/src/constants/errors.ts

@@ -0,0 +1,29 @@
+/**
+ * Centralized error message constants for backend operations
+ * Reduces duplication across 6 backend implementations
+ */
+
+export const FILE_NOT_FOUND = (path: string) =>
+  `Error: File '${path}' not found`;
+
+export const FILE_ALREADY_EXISTS = (path: string) =>
+  `Cannot write to ${path} because it already exists. Read and then make an edit, or write to a new path.`;
+
+export const STRING_NOT_FOUND = (path: string, string: string) =>
+  `Error: String not found in file: '${path}'\n\n${string}`;
+
+export const INVALID_REGEX = (message: string) =>
+  `Invalid regex pattern: ${message}`;
+
+export const WEB_SEARCH_ERROR = (message: string) =>
+  `Web search error: ${message}`;
+
+export const REQUEST_TIMEOUT = (timeout: number) =>
+  `Request timed out after ${timeout} seconds`;
+
+export const SYSTEM_REMINDER_FILE_EMPTY =
+  'System reminder: File exists but has empty contents';
+
+// Generic errors
+export const OPERATION_ERROR = (operation: string, message: string) =>
+  `Operation error: ${operation} - ${message}`;