gencode-ai 0.1.0 → 0.1.1

package/src/cli/components/theme.ts

@@ -14,6 +14,7 @@ export const colors = {
   textMuted: '#64748B', // Slate 500
   tool: '#C084FC', // Purple 400
   separator: '#1E293B', // Slate 800
+  inputBg: '#111827', // Gray 900 - subtle background for user input
 };
 
 export const icons = {
@@ -29,8 +30,14 @@ export const icons = {
   info: 'ℹ',
   // Tools
   tool: '⚡', // Lightning for tools
+  fetch: '●', // Filled circle for fetch (Claude Code style)
   arrow: '→',
   // UI
   thinking: '✱', // Star for thinking state
   cursor: '▋',
+  // Selection
+  radio: '●', // Filled radio for selected
+  radioEmpty: '○', // Empty radio for unselected
+  // Tree connectors
+  treeEnd: '└', // Tree end connector for tool results
 };

package/src/cli/index.tsx

@@ -9,7 +9,7 @@ import { render } from 'ink';
 import React from 'react';
 import { App } from './components/App.js';
 import type { AgentConfig } from '../agent/types.js';
-import { SettingsManager, type Settings } from '../config/index.js';
+import { SettingsManager, ProvidersConfigManager, type Settings, type ProviderName } from '../config/index.js';
 
 // ============================================================================
 // Proxy Setup
@@ -31,12 +31,17 @@ async function setupProxy(): Promise<void> {
 // ============================================================================
 // Configuration
 // ============================================================================
-function detectConfig(settings: Settings): AgentConfig {
-  let provider: 'openai' | 'anthropic' | 'gemini' = 'gemini';
+function detectConfig(settings: Settings, providersConfig: ProvidersConfigManager): AgentConfig {
+  let provider: ProviderName = 'gemini';
   let model = 'gemini-2.0-flash';
 
+  // Check for explicit Vertex AI enablement first (highest priority for auto-detect)
+  if (process.env.GENCODE_USE_VERTEX === '1' || process.env.CLAUDE_CODE_USE_VERTEX === '1') {
+    provider = 'vertex-ai';
+    model = process.env.VERTEX_AI_MODEL ?? 'claude-sonnet-4-5@20250929';
+  }
   // Auto-detect from API keys
-  if (process.env.ANTHROPIC_API_KEY) {
+  else if (process.env.ANTHROPIC_API_KEY) {
     provider = 'anthropic';
     model = 'claude-sonnet-4-20250514';
   } else if (process.env.OPENAI_API_KEY) {
@@ -49,7 +54,7 @@ function detectConfig(settings: Settings): AgentConfig {
 
   // Override from env vars
   if (process.env.GENCODE_PROVIDER) {
-    provider = process.env.GENCODE_PROVIDER as 'openai' | 'anthropic' | 'gemini';
+    provider = process.env.GENCODE_PROVIDER as ProviderName;
   }
   if (process.env.GENCODE_MODEL) {
     model = process.env.GENCODE_MODEL;
@@ -61,6 +66,13 @@ function detectConfig(settings: Settings): AgentConfig {
   }
   if (settings.model) {
     model = settings.model;
+    // Auto-infer provider from model using providers.json (if not explicitly set)
+    if (!settings.provider) {
+      const inferredProvider = providersConfig.inferProvider(model);
+      if (inferredProvider) {
+        provider = inferredProvider;
+      }
+    }
   }
 
   return {
@@ -114,11 +126,14 @@ async function main() {
 
   await setupProxy();
 
-  // Load saved settings
+  // Load saved settings and providers config
   const settingsManager = new SettingsManager();
   const settings = await settingsManager.load();
 
-  const config = detectConfig(settings);
+  const providersConfig = new ProvidersConfigManager();
+  await providersConfig.load();
+
+  const config = detectConfig(settings, providersConfig);
 
   // Render the Ink app
   render(

package/src/config/index.ts

@@ -3,5 +3,6 @@
  */
 
 export { SettingsManager } from './manager.js';
-export type { Settings, SettingsManagerOptions, ProviderName } from './types.js';
-export { DEFAULT_SETTINGS_DIR, SETTINGS_FILE_NAME } from './types.js';
+export { ProvidersConfigManager } from './providers-config.js';
+export type { Settings, SettingsManagerOptions, ProviderName, ProvidersConfig } from './types.js';
+export { DEFAULT_SETTINGS_DIR, SETTINGS_FILE_NAME, PROVIDERS_FILE_NAME } from './types.js';

package/src/config/providers-config.ts

@@ -0,0 +1,85 @@
+/**
+ * Providers Config Manager - Reads providers.json for model-to-provider mapping
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import type { ProvidersConfig, ProviderName } from './types.js';
+import { DEFAULT_SETTINGS_DIR, PROVIDERS_FILE_NAME } from './types.js';
+
+export class ProvidersConfigManager {
+  private settingsDir: string;
+  private providersPath: string;
+  private config: ProvidersConfig | null = null;
+
+  constructor(settingsDir?: string) {
+    const dir = settingsDir ?? DEFAULT_SETTINGS_DIR;
+    this.settingsDir = dir.replace('~', os.homedir());
+    this.providersPath = path.join(this.settingsDir, PROVIDERS_FILE_NAME);
+  }
+
+  /**
+   * Load providers config from disk
+   */
+  async load(): Promise<ProvidersConfig | null> {
+    try {
+      const content = await fs.readFile(this.providersPath, 'utf-8');
+      this.config = JSON.parse(content);
+      return this.config;
+    } catch {
+      // File doesn't exist or is invalid
+      this.config = null;
+      return null;
+    }
+  }
+
+  /**
+   * Get cached config (call load() first)
+   */
+  get(): ProvidersConfig | null {
+    return this.config;
+  }
+
+  /**
+   * Infer provider from model ID using cached models in providers.json
+   * Returns undefined if model not found in any provider's cached list
+   */
+  inferProvider(modelId: string): ProviderName | undefined {
+    if (!this.config?.models) {
+      return undefined;
+    }
+
+    for (const [providerKey, providerModels] of Object.entries(this.config.models)) {
+      const found = providerModels.list?.some((m) => m.id === modelId);
+      if (found) {
+        // Map provider key to ProviderName
+        // Note: 'anthropic' in providers.json might use vertex connection
+        if (providerKey === 'gemini') {
+          return 'gemini';
+        } else if (providerKey === 'anthropic') {
+          // Check connection method to determine if vertex or direct
+          const connection = this.config.connections?.[providerKey];
+          if (connection?.method === 'vertex') {
+            return 'vertex-ai';
+          }
+          return 'anthropic';
+        } else if (providerKey === 'openai') {
+          return 'openai';
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Get all model IDs for a provider
+   */
+  getModelIds(provider: string): string[] {
+    if (!this.config?.models?.[provider]) {
+      return [];
+    }
+    return this.config.models[provider].list?.map((m) => m.id) ?? [];
+  }
+}

package/src/config/types.ts

@@ -2,7 +2,7 @@
  * Settings Types - User settings persistence (Claude Code style)
  */
 
-export type ProviderName = 'openai' | 'anthropic' | 'gemini';
+export type ProviderName = 'openai' | 'anthropic' | 'gemini' | 'vertex-ai';
 
 /**
  * Settings file structure (~/.gencode/settings.json)
@@ -23,3 +23,37 @@ export interface SettingsManagerOptions {
 
 export const DEFAULT_SETTINGS_DIR = '~/.gencode';
 export const SETTINGS_FILE_NAME = 'settings.json';
+export const PROVIDERS_FILE_NAME = 'providers.json';
+
+/**
+ * Provider connection info
+ */
+export interface ProviderConnection {
+  method: 'api_key' | 'vertex' | 'oauth';
+  connectedAt: string;
+}
+
+/**
+ * Cached model info
+ */
+export interface CachedModel {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+/**
+ * Cached models for a provider
+ */
+export interface ProviderModels {
+  cachedAt: string;
+  list: CachedModel[];
+}
+
+/**
+ * Providers config file structure (~/.gencode/providers.json)
+ */
+export interface ProvidersConfig {
+  connections: Record<string, ProviderConnection>;
+  models: Record<string, ProviderModels>;
+}

package/src/providers/gemini.ts

@@ -65,7 +65,12 @@ export class GeminiProvider implements LLMProvider {
     const result = await model.generateContentStream({ contents });
 
     let textContent = '';
-    const functionCalls: Array<{ id: string; name: string; args: Record<string, unknown> }> = [];
+    const functionCalls: Array<{
+      id: string;
+      name: string;
+      args: Record<string, unknown>;
+      thoughtSignature?: string;
+    }> = [];
     let callIndex = 0;
 
     for await (const chunk of result.stream) {
@@ -78,10 +83,13 @@ export class GeminiProvider implements LLMProvider {
         } else if ('functionCall' in part && part.functionCall) {
           const fc = part.functionCall;
           const id = `call_${callIndex++}`;
+          // Capture thoughtSignature for Gemini 3+ models
+          const partAny = part as { thoughtSignature?: string };
           functionCalls.push({
             id,
             name: fc.name,
             args: (fc.args as Record<string, unknown>) ?? {},
+            thoughtSignature: partAny.thoughtSignature,
           });
           yield { type: 'tool_start', id, name: fc.name };
           yield { type: 'tool_input', id, input: JSON.stringify(fc.args) };
@@ -100,6 +108,7 @@ export class GeminiProvider implements LLMProvider {
         id: fc.id,
         name: fc.name,
         input: fc.args,
+        thoughtSignature: fc.thoughtSignature,
       });
     }
 
@@ -152,13 +161,17 @@ export class GeminiProvider implements LLMProvider {
       if (item.type === 'text') {
         parts.push({ text: item.text });
       } else if (item.type === 'tool_use' && role === 'model') {
-        // Function call from model
-        parts.push({
+        // Function call from model - include thoughtSignature for Gemini 3+
+        const fcPart: Part & { thoughtSignature?: string } = {
           functionCall: {
             name: item.name,
             args: item.input,
           },
-        });
+        };
+        if (item.thoughtSignature) {
+          fcPart.thoughtSignature = item.thoughtSignature;
+        }
+        parts.push(fcPart as Part);
       } else if (item.type === 'tool_result' && role === 'user') {
         // Function response
         parts.push({
@@ -234,11 +247,14 @@ export class GeminiProvider implements LLMProvider {
       if ('text' in part && part.text) {
         content.push({ type: 'text', text: part.text });
       } else if ('functionCall' in part && part.functionCall) {
+        // Capture thoughtSignature for Gemini 3+ models
+        const partAny = part as { thoughtSignature?: string };
         content.push({
           type: 'tool_use',
           id: `call_${callIndex++}`,
           name: part.functionCall.name,
           input: (part.functionCall.args as Record<string, unknown>) ?? {},
+          thoughtSignature: partAny.thoughtSignature,
         });
       }
     }

package/src/providers/index.ts

@@ -1,22 +1,25 @@
 /**
- * LLM Providers - Unified interface for OpenAI, Anthropic, and Gemini
+ * LLM Providers - Unified interface for OpenAI, Anthropic, Gemini, and Vertex AI
  */
 
 export * from './types.js';
 export { OpenAIProvider } from './openai.js';
 export { AnthropicProvider } from './anthropic.js';
 export { GeminiProvider } from './gemini.js';
+export { VertexAIProvider } from './vertex-ai.js';
 
-import type { LLMProvider, OpenAIConfig, AnthropicConfig, GeminiConfig } from './types.js';
+import type { LLMProvider, OpenAIConfig, AnthropicConfig, GeminiConfig, VertexAIConfig } from './types.js';
 import { OpenAIProvider } from './openai.js';
 import { AnthropicProvider } from './anthropic.js';
 import { GeminiProvider } from './gemini.js';
+import { VertexAIProvider } from './vertex-ai.js';
 
-export type ProviderName = 'openai' | 'anthropic' | 'gemini';
+export type ProviderName = 'openai' | 'anthropic' | 'gemini' | 'vertex-ai';
 export type ProviderConfigMap = {
   openai: OpenAIConfig;
   anthropic: AnthropicConfig;
   gemini: GeminiConfig;
+  'vertex-ai': VertexAIConfig;
 };
 
 export interface CreateProviderOptions<T extends ProviderName = ProviderName> {
@@ -35,6 +38,8 @@ export function createProvider(options: CreateProviderOptions): LLMProvider {
       return new AnthropicProvider(options.config as AnthropicConfig);
     case 'gemini':
       return new GeminiProvider(options.config as GeminiConfig);
+    case 'vertex-ai':
+      return new VertexAIProvider(options.config as VertexAIConfig);
     default:
       throw new Error(`Unknown provider: ${options.provider}`);
   }
@@ -46,6 +51,11 @@ export function createProvider(options: CreateProviderOptions): LLMProvider {
 export function inferProvider(model: string): ProviderName {
   const modelLower = model.toLowerCase();
 
+  // Vertex AI models (Claude models with @ version suffix like claude-sonnet-4-5@20250929)
+  if (modelLower.includes('claude') && modelLower.includes('@')) {
+    return 'vertex-ai';
+  }
+
   // OpenAI models
   if (
     modelLower.includes('gpt') ||
@@ -94,4 +104,9 @@ export const ModelAliases: Record<string, { provider: ProviderName; model: strin
   'gemini-2.0-flash': { provider: 'gemini', model: 'gemini-2.0-flash' },
   'gemini-1.5-pro': { provider: 'gemini', model: 'gemini-1.5-pro' },
   'gemini-1.5-flash': { provider: 'gemini', model: 'gemini-1.5-flash' },
+
+  // Vertex AI (Claude on GCP)
+  'vertex-sonnet': { provider: 'vertex-ai', model: 'claude-sonnet-4-5@20250929' },
+  'vertex-haiku': { provider: 'vertex-ai', model: 'claude-haiku-4-5@20251001' },
+  'vertex-opus': { provider: 'vertex-ai', model: 'claude-opus-4-1@20250805' },
 };

package/src/providers/registry.ts

@@ -0,0 +1,198 @@
+/**
+ * Provider Registry - Provider definitions with connection options
+ */
+
+import type { ProviderName } from './index.js';
+import type { SearchProviderName } from './search/types.js';
+
+export interface ConnectionOption {
+  method: string;
+  name: string;
+  envVars: string[];
+  description?: string;
+  providerImpl?: ProviderName; // Override provider implementation (e.g., vertex-ai for Anthropic via GCP)
+}
+
+export interface ProviderDefinition {
+  id: ProviderName;
+  name: string;
+  popularity: number; // Lower = more popular, used for sorting
+  connections: ConnectionOption[];
+}
+
+export interface SearchProviderDefinition {
+  id: SearchProviderName;
+  name: string;
+  popularity: number;
+  connections: ConnectionOption[];
+  requiresKey: boolean;
+}
+
+/**
+ * All supported providers with their connection options
+ */
+export const PROVIDERS: ProviderDefinition[] = [
+  {
+    id: 'anthropic',
+    name: 'Anthropic',
+    popularity: 1,
+    connections: [
+      {
+        method: 'api_key',
+        name: 'API Key',
+        envVars: ['ANTHROPIC_API_KEY'],
+        description: 'Direct API access',
+      },
+      {
+        method: 'vertex',
+        name: 'Google Vertex AI',
+        envVars: ['ANTHROPIC_VERTEX_PROJECT_ID', 'GOOGLE_CLOUD_PROJECT'],
+        description: 'Claude via GCP',
+        providerImpl: 'vertex-ai',
+      },
+      {
+        method: 'bedrock',
+        name: 'Amazon Bedrock',
+        envVars: ['AWS_ACCESS_KEY_ID', 'AWS_PROFILE'],
+        description: 'Claude via AWS (coming soon)',
+      },
+    ],
+  },
+  {
+    id: 'openai',
+    name: 'OpenAI',
+    popularity: 2,
+    connections: [
+      {
+        method: 'api_key',
+        name: 'API Key',
+        envVars: ['OPENAI_API_KEY'],
+        description: 'Direct API access',
+      },
+    ],
+  },
+  {
+    id: 'gemini',
+    name: 'Google Gemini',
+    popularity: 3,
+    connections: [
+      {
+        method: 'api_key',
+        name: 'API Key',
+        envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+        description: 'Direct API access',
+      },
+    ],
+  },
+];
+
+/**
+ * All supported search providers
+ */
+export const SEARCH_PROVIDERS: SearchProviderDefinition[] = [
+  {
+    id: 'exa',
+    name: 'Exa AI',
+    popularity: 1,
+    connections: [
+      {
+        method: 'public',
+        name: 'Public API',
+        envVars: [],
+        description: 'No API key required',
+      },
+    ],
+    requiresKey: false,
+  },
+  {
+    id: 'serper',
+    name: 'Serper.dev',
+    popularity: 2,
+    connections: [
+      {
+        method: 'api_key',
+        name: 'API Key',
+        envVars: ['SERPER_API_KEY'],
+        description: 'Google Search via Serper',
+      },
+    ],
+    requiresKey: true,
+  },
+  {
+    id: 'brave',
+    name: 'Brave Search',
+    popularity: 3,
+    connections: [
+      {
+        method: 'api_key',
+        name: 'API Key',
+        envVars: ['BRAVE_API_KEY'],
+        description: 'Privacy-focused search',
+      },
+    ],
+    requiresKey: true,
+  },
+];
+
+/**
+ * Get provider definition by ID
+ */
+export function getProvider(id: ProviderName): ProviderDefinition | undefined {
+  return PROVIDERS.find((p) => p.id === id);
+}
+
+/**
+ * Get search provider definition by ID
+ */
+export function getSearchProvider(id: SearchProviderName): SearchProviderDefinition | undefined {
+  return SEARCH_PROVIDERS.find((p) => p.id === id);
+}
+
+/**
+ * Get all search providers sorted by popularity
+ */
+export function getSearchProvidersSorted(): SearchProviderDefinition[] {
+  return [...SEARCH_PROVIDERS].sort((a, b) => a.popularity - b.popularity);
+}
+
+/**
+ * Get all providers sorted by popularity
+ */
+export function getProvidersSorted(): ProviderDefinition[] {
+  return [...PROVIDERS].sort((a, b) => a.popularity - b.popularity);
+}
+
+// Helper: check if any env var in the list is set
+const hasAnyEnvVar = (envVars: string[]) => envVars.some((v) => !!process.env[v]);
+
+/**
+ * Check if any of the provider's env vars are set
+ */
+export function hasEnvVars(provider: ProviderDefinition): boolean {
+  return provider.connections.some((conn) => hasAnyEnvVar(conn.envVars));
+}
+
+/**
+ * Get the first available connection method (where env vars are set)
+ */
+export function getAvailableConnection(
+  provider: ProviderDefinition
+): ConnectionOption | undefined {
+  return provider.connections.find((conn) => hasAnyEnvVar(conn.envVars));
+}
+
+/**
+ * Check if a specific connection option has its env vars set
+ */
+export function isConnectionReady(conn: ConnectionOption): boolean {
+  return hasAnyEnvVar(conn.envVars);
+}
+
+/**
+ * Get all available (ready) connections for a provider
+ */
+export function getAvailableConnections(
+  provider: ProviderDefinition
+): ConnectionOption[] {
+  return provider.connections.filter((conn) => hasAnyEnvVar(conn.envVars));
+}

package/src/providers/search/brave.ts

@@ -0,0 +1,132 @@
+/**
+ * Brave Search Provider
+ *
+ * Uses Brave Search API (same as Claude Code).
+ * Requires BRAVE_API_KEY environment variable.
+ */
+
+import type { SearchProvider, SearchResult, SearchOptions } from './types.js';
+
+const API_CONFIG = {
+  BASE_URL: 'https://api.search.brave.com',
+  ENDPOINT: '/res/v1/web/search',
+  DEFAULT_NUM_RESULTS: 10,
+  DEFAULT_TIMEOUT: 10000,
+} as const;
+
+interface BraveWebResult {
+  title: string;
+  url: string;
+  description: string;
+  is_source_local?: boolean;
+  is_source_both?: boolean;
+}
+
+interface BraveResponse {
+  web?: {
+    results: BraveWebResult[];
+  };
+  query?: {
+    original: string;
+  };
+}
+
+/**
+ * Filter results by allowed/blocked domains
+ */
+function filterByDomain(results: SearchResult[], options?: SearchOptions): SearchResult[] {
+  if (!options?.allowedDomains?.length && !options?.blockedDomains?.length) {
+    return results;
+  }
+
+  return results.filter((result) => {
+    try {
+      const domain = new URL(result.url).hostname;
+
+      if (options.allowedDomains?.length) {
+        return options.allowedDomains.some(
+          (allowed) => domain === allowed || domain.endsWith('.' + allowed)
+        );
+      }
+
+      if (options.blockedDomains?.length) {
+        return !options.blockedDomains.some(
+          (blocked) => domain === blocked || domain.endsWith('.' + blocked)
+        );
+      }
+
+      return true;
+    } catch {
+      return true;
+    }
+  });
+}
+
+export class BraveProvider implements SearchProvider {
+  readonly name = 'brave' as const;
+  private apiKey: string;
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey ?? process.env.BRAVE_API_KEY ?? '';
+    if (!this.apiKey) {
+      throw new Error('BRAVE_API_KEY environment variable is required for Brave provider');
+    }
+  }
+
+  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const params = new URLSearchParams({
+      q: query,
+      count: String(options?.numResults ?? API_CONFIG.DEFAULT_NUM_RESULTS),
+    });
+
+    const controller = new AbortController();
+    const timeoutId = setTimeout(
+      () => controller.abort(),
+      options?.timeout ?? API_CONFIG.DEFAULT_TIMEOUT
+    );
+
+    try {
+      const signals = options?.abortSignal
+        ? [controller.signal, options.abortSignal]
+        : [controller.signal];
+
+      const response = await fetch(
+        `${API_CONFIG.BASE_URL}${API_CONFIG.ENDPOINT}?${params.toString()}`,
+        {
+          method: 'GET',
+          headers: {
+            Accept: 'application/json',
+            'Accept-Encoding': 'gzip',
+            'X-Subscription-Token': this.apiKey,
+          },
+          signal: AbortSignal.any(signals),
+        }
+      );
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Brave search error (${response.status}): ${errorText}`);
+      }
+
+      const data = (await response.json()) as BraveResponse;
+
+      const results: SearchResult[] = (data.web?.results || []).map((item) => ({
+        title: item.title,
+        url: item.url,
+        snippet: item.description,
+      }));
+
+      return filterByDomain(results, options);
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Search request timed out');
+      }
+
+      throw error;
+    }
+  }
+}