gencode-ai 0.2.0 → 0.3.0

package/src/providers/registry.ts

@@ -1,23 +1,128 @@
 /**
- * Provider Registry - Provider definitions with connection options
+ * Provider Registry - Provider class registry with metadata
  */
 
-import type { ProviderName } from './index.js';
+import type { Provider, AuthMethod, ProviderClassMeta, LLMProvider } from './types.js';
 import type { SearchProviderName } from './search/types.js';
+import { AnthropicProvider } from './anthropic.js';
+import { AnthropicVertexProvider } from './vertex-ai.js';
+import { OpenAIProvider } from './openai.js';
+import { GeminiProvider } from './gemini.js';
 
-export interface ConnectionOption {
-  method: string;
+// ============================================================================
+// LLM Provider Classes
+// ============================================================================
+
+export type ProviderClass = {
+  new (config?: any): LLMProvider;
+  meta: ProviderClassMeta;
+};
+
+/**
+ * All registered provider classes
+ * Each class has static metadata describing which provider and auth method it implements
+ */
+export const PROVIDER_CLASSES: ProviderClass[] = [
+  AnthropicProvider,
+  AnthropicVertexProvider,
+  OpenAIProvider,
+  GeminiProvider,
+];
+
+/**
+ * Provider metadata (for UI display)
+ */
+export interface ProviderMeta {
+  id: Provider;
   name: string;
-  envVars: string[];
-  description?: string;
-  providerImpl?: ProviderName; // Override provider implementation (e.g., vertex-ai for Anthropic via GCP)
+  popularity: number; // Lower = more popular
+}
+
+export const PROVIDER_METADATA: ProviderMeta[] = [
+  { id: 'anthropic', name: 'Anthropic', popularity: 1 },
+  { id: 'openai', name: 'OpenAI', popularity: 2 },
+  { id: 'gemini', name: 'Google Gemini', popularity: 3 },
+];
+
+// ============================================================================
+// Helper Functions
+// ============================================================================
+
+/**
+ * Get a specific provider class by provider and auth method
+ */
+export function getProviderClass(
+  provider: Provider,
+  authMethod: AuthMethod
+): ProviderClass | undefined {
+  return PROVIDER_CLASSES.find(
+    (cls) => cls.meta.provider === provider && cls.meta.authMethod === authMethod
+  );
 }
 
-export interface ProviderDefinition {
-  id: ProviderName;
+/**
+ * Get all provider classes for a given provider
+ */
+export function getProviderClasses(provider: Provider): ProviderClass[] {
+  return PROVIDER_CLASSES.filter((cls) => cls.meta.provider === provider);
+}
+
+/**
+ * Check if a provider class is ready (has required env vars)
+ */
+export function isProviderReady(providerClass: ProviderClass): boolean {
+  // Special case for Vertex AI: requires explicit opt-in
+  if (providerClass.meta.authMethod === 'vertex') {
+    const useVertex = process.env.CLAUDE_CODE_USE_VERTEX === '1' || process.env.CLAUDE_CODE_USE_VERTEX === 'true';
+    const hasProject = !!(
+      process.env.ANTHROPIC_VERTEX_PROJECT_ID ||
+      process.env.GCLOUD_PROJECT ||
+      process.env.GOOGLE_CLOUD_PROJECT
+    );
+    return useVertex && hasProject;
+  }
+
+  // For other providers: check if any required env var is set
+  return providerClass.meta.envVars.some((v) => !!process.env[v]);
+}
+
+/**
+ * Get provider metadata by ID
+ */
+export function getProviderMeta(id: Provider): ProviderMeta | undefined {
+  return PROVIDER_METADATA.find((p) => p.id === id);
+}
+
+/**
+ * Get all providers sorted by popularity
+ */
+export function getProvidersSorted(): ProviderMeta[] {
+  return [...PROVIDER_METADATA].sort((a, b) => a.popularity - b.popularity);
+}
+
+/**
+ * Get the first available (ready) provider class for a provider
+ */
+export function getAvailableProviderClass(provider: Provider): ProviderClass | undefined {
+  const classes = getProviderClasses(provider);
+  return classes.find((cls) => isProviderReady(cls));
+}
+
+/**
+ * Get all available (ready) provider classes for a provider
+ */
+export function getAvailableProviderClasses(provider: Provider): ProviderClass[] {
+  return getProviderClasses(provider).filter((cls) => isProviderReady(cls));
+}
+
+// ============================================================================
+// Legacy Support (for backward compatibility with search providers)
+// ============================================================================
+
+export interface ConnectionOption {
   name: string;
-  popularity: number; // Lower = more popular, used for sorting
-  connections: ConnectionOption[];
+  envVars: string[];
+  description?: string;
 }
 
 export interface SearchProviderDefinition {
@@ -28,64 +133,6 @@ export interface SearchProviderDefinition {
   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
  */
@@ -96,7 +143,6 @@ export const SEARCH_PROVIDERS: SearchProviderDefinition[] = [
     popularity: 1,
     connections: [
       {
-        method: 'public',
         name: 'Public API',
         envVars: [],
         description: 'No API key required',
@@ -110,7 +156,6 @@ export const SEARCH_PROVIDERS: SearchProviderDefinition[] = [
     popularity: 2,
     connections: [
       {
-        method: 'api_key',
         name: 'API Key',
         envVars: ['SERPER_API_KEY'],
         description: 'Google Search via Serper',
@@ -124,7 +169,6 @@ export const SEARCH_PROVIDERS: SearchProviderDefinition[] = [
     popularity: 3,
     connections: [
       {
-        method: 'api_key',
         name: 'API Key',
         envVars: ['BRAVE_API_KEY'],
         description: 'Privacy-focused search',
@@ -134,13 +178,6 @@ export const SEARCH_PROVIDERS: SearchProviderDefinition[] = [
   },
 ];
 
-/**
- * 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
  */
@@ -155,44 +192,12 @@ 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/store.ts

@@ -1,13 +1,13 @@
 /**
  * Provider Store - Manages provider connections and model cache
  *
- * Storage location: ~/.gencode/providers.json
+ * Storage location: ~/.gen/providers.json
  */
 
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
-import type { ProviderName } from './index.js';
+import type { Provider, AuthMethod } from './types.js';
 import type { SearchProviderName } from './search/types.js';
 
 export interface ModelInfo {
@@ -16,7 +16,8 @@ export interface ModelInfo {
 }
 
 export interface ProviderConnection {
-  method: string;
+  authMethod: AuthMethod; // Authentication method
+  method?: string; // Legacy: Connection name (e.g., "Direct API", "Google Vertex AI")
   connectedAt: string;
 }
 
@@ -31,9 +32,28 @@ export interface ProvidersConfig {
   searchProvider?: SearchProviderName;
 }
 
-const CONFIG_DIR = join(homedir(), '.gencode');
+const CONFIG_DIR = join(homedir(), '.gen');
 const CONFIG_FILE = join(CONFIG_DIR, 'providers.json');
 
+/**
+ * Generate model cache key from provider and authMethod
+ */
+export function getModelCacheKey(provider: Provider, authMethod: AuthMethod): string {
+  return `${provider}:${authMethod}`;
+}
+
+/**
+ * Parse model cache key to extract provider and authMethod
+ */
+export function parseModelCacheKey(key: string): { provider: Provider; authMethod: AuthMethod } | null {
+  const parts = key.split(':');
+  if (parts.length !== 2) return null;
+  return {
+    provider: parts[0] as Provider,
+    authMethod: parts[1] as AuthMethod,
+  };
+}
+
 /**
  * Provider Store - manages connection state and model cache
  */
@@ -76,67 +96,93 @@ export class ProviderStore {
   /**
    * Check if a provider is connected
    */
-  isConnected(providerId: ProviderName): boolean {
+  isConnected(providerId: Provider): boolean {
     return !!this.config.connections[providerId];
   }
 
   /**
    * Get connection info for a provider
    */
-  getConnection(providerId: ProviderName): ProviderConnection | undefined {
+  getConnection(providerId: Provider): ProviderConnection | undefined {
     return this.config.connections[providerId];
   }
 
   /**
    * Get all connected provider IDs
    */
-  getConnectedProviders(): ProviderName[] {
-    return Object.keys(this.config.connections) as ProviderName[];
+  getConnectedProviders(): Provider[] {
+    return Object.keys(this.config.connections) as Provider[];
   }
 
   /**
-   * Connect a provider
+   * Connect a provider with auth method
    */
-  connect(providerId: ProviderName, method: string): void {
+  connect(providerId: Provider, authMethod: AuthMethod, displayName?: string): void {
     this.config.connections[providerId] = {
-      method,
+      authMethod,
+      method: displayName, // Optional legacy field for display
       connectedAt: new Date().toISOString(),
     };
     this.save();
   }
 
   /**
-   * Disconnect a provider
+   * Disconnect a provider and clear all its model caches
    */
-  disconnect(providerId: ProviderName): void {
+  disconnect(providerId: Provider): void {
     delete this.config.connections[providerId];
-    delete this.config.models[providerId];
+
+    // Remove all model caches for this provider (across all authMethods)
+    for (const key of Object.keys(this.config.models)) {
+      const parsed = parseModelCacheKey(key);
+      if (parsed && parsed.provider === providerId) {
+        delete this.config.models[key];
+      }
+    }
+
     this.save();
   }
 
   /**
    * Get cached models for a provider
+   * @param providerId Provider ID
+   * @param authMethod Optional: specific auth method. If not provided, returns all models for the provider
    */
-  getModels(providerId: ProviderName): ModelInfo[] {
-    return this.config.models[providerId]?.list ?? [];
+  getModels(providerId: Provider, authMethod?: AuthMethod): ModelInfo[] {
+    if (authMethod) {
+      // Get models for specific authMethod
+      const key = getModelCacheKey(providerId, authMethod);
+      return this.config.models[key]?.list ?? [];
+    }
+
+    // Get all models for this provider (across all authMethods)
+    const allModels: ModelInfo[] = [];
+    for (const [key, cache] of Object.entries(this.config.models)) {
+      const parsed = parseModelCacheKey(key);
+      if (parsed && parsed.provider === providerId) {
+        allModels.push(...cache.list);
+      }
+    }
+    return allModels;
   }
 
   /**
    * Get all cached models grouped by provider
    */
-  getAllModels(): Record<ProviderName, ModelInfo[]> {
+  getAllModels(): Record<Provider, ModelInfo[]> {
     const result: Record<string, ModelInfo[]> = {};
     for (const [providerId, cache] of Object.entries(this.config.models)) {
       result[providerId] = cache.list;
     }
-    return result as Record<ProviderName, ModelInfo[]>;
+    return result as Record<Provider, ModelInfo[]>;
   }
 
   /**
-   * Cache models for a provider
+   * Cache models for a provider with auth method
    */
-  cacheModels(providerId: ProviderName, models: ModelInfo[]): void {
-    this.config.models[providerId] = {
+  cacheModels(providerId: Provider, authMethod: AuthMethod, models: ModelInfo[]): void {
+    const key = getModelCacheKey(providerId, authMethod);
+    this.config.models[key] = {
       cachedAt: new Date().toISOString(),
       list: models,
     };
@@ -145,17 +191,37 @@ export class ProviderStore {
 
   /**
    * Get cache timestamp for a provider
+   * @param providerId Provider ID
+   * @param authMethod Optional: specific auth method. If not provided, returns latest cache time
    */
-  getCacheTime(providerId: ProviderName): Date | undefined {
-    const cache = this.config.models[providerId];
-    return cache ? new Date(cache.cachedAt) : undefined;
+  getCacheTime(providerId: Provider, authMethod?: AuthMethod): Date | undefined {
+    if (authMethod) {
+      const key = getModelCacheKey(providerId, authMethod);
+      const cache = this.config.models[key];
+      return cache ? new Date(cache.cachedAt) : undefined;
+    }
+
+    // Get latest cache time across all authMethods for this provider
+    let latestTime: Date | undefined;
+    for (const [key, cache] of Object.entries(this.config.models)) {
+      const parsed = parseModelCacheKey(key);
+      if (parsed && parsed.provider === providerId) {
+        const cacheTime = new Date(cache.cachedAt);
+        if (!latestTime || cacheTime > latestTime) {
+          latestTime = cacheTime;
+        }
+      }
+    }
+    return latestTime;
   }
 
   /**
    * Check if model cache is stale (older than 24 hours)
+   * @param providerId Provider ID
+   * @param authMethod Optional: specific auth method. If not provided, checks if any cache is fresh
    */
-  isCacheStale(providerId: ProviderName): boolean {
-    const cacheTime = this.getCacheTime(providerId);
+  isCacheStale(providerId: Provider, authMethod?: AuthMethod): boolean {
+    const cacheTime = this.getCacheTime(providerId, authMethod);
     if (!cacheTime) return true;
     const hoursSinceCache = (Date.now() - cacheTime.getTime()) / (1000 * 60 * 60);
     return hoursSinceCache > 24;
@@ -173,9 +239,45 @@ export class ProviderStore {
 
   /**
    * Get model count for a specific provider
+   * @param providerId Provider ID
+   * @param authMethod Optional: specific auth method. If not provided, counts all models for the provider
+   */
+  getModelCount(providerId: Provider, authMethod?: AuthMethod): number {
+    if (authMethod) {
+      const key = getModelCacheKey(providerId, authMethod);
+      return this.config.models[key]?.list.length ?? 0;
+    }
+
+    // Count all models for this provider (across all authMethods)
+    let count = 0;
+    for (const [key, cache] of Object.entries(this.config.models)) {
+      const parsed = parseModelCacheKey(key);
+      if (parsed && parsed.provider === providerId) {
+        count += cache.list.length;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * Get the model cache info
+   * @param providerId Provider ID
+   * @param authMethod Optional: specific auth method
    */
-  getModelCount(providerId: ProviderName): number {
-    return this.config.models[providerId]?.list.length ?? 0;
+  getModelCache(providerId: Provider, authMethod?: AuthMethod): ModelCache | undefined {
+    if (authMethod) {
+      const key = getModelCacheKey(providerId, authMethod);
+      return this.config.models[key];
+    }
+
+    // If no authMethod specified, try to find any cache for this provider
+    for (const [key, cache] of Object.entries(this.config.models)) {
+      const parsed = parseModelCacheKey(key);
+      if (parsed && parsed.provider === providerId) {
+        return cache;
+      }
+    }
+    return undefined;
   }
 
   /**

package/src/providers/types.ts

@@ -5,6 +5,36 @@
 
 import type { CostEstimate } from '../pricing/types.js';
 
+// ============================================================================
+// Provider Types
+// ============================================================================
+
+/**
+ * Provider - Semantic layer (only 3 providers)
+ */
+export type Provider = 'anthropic' | 'openai' | 'gemini';
+
+/**
+ * Authentication method for providers
+ */
+export type AuthMethod = 'api_key' | 'vertex' | 'bedrock' | 'azure' | 'oauth';
+
+/**
+ * Provider class metadata (static property on each provider implementation)
+ */
+export interface ProviderClassMeta {
+  /** Which provider this class implements */
+  provider: Provider;
+  /** Authentication method */
+  authMethod: AuthMethod;
+  /** Environment variables required for this auth method */
+  envVars: string[];
+  /** Display name for UI */
+  displayName: string;
+  /** Optional description */
+  description?: string;
+}
+
 // ============================================================================
 // Message Types
 // ============================================================================
@@ -104,7 +134,9 @@ export interface CompletionResponse {
 export interface StreamChunkText {
   type: 'text';
   text: string;
-}
+}/* The above code appears to be a comment block in TypeScript. It includes a placeholder
+text "ANTHROPIC_VERTEX_PROJECT_ID" and " */
+
 
 export interface StreamChunkToolStart {
   type: 'tool_start';

package/src/providers/vertex-ai.ts

@@ -1,10 +1,17 @@
 /**
- * Google Vertex AI Provider Implementation
- * Supports Claude models deployed on Google Cloud Vertex AI
+ * Anthropic Vertex AI Provider
+ * Supports Claude models via Google Cloud Vertex AI
+ *
+ * Documentation: https://code.claude.com/docs/en/google-vertex-ai
+ *
+ * Required environment variables:
+ * - CLAUDE_CODE_USE_VERTEX=1
+ * - ANTHROPIC_VERTEX_PROJECT_ID=your-project-id
+ * - CLOUD_ML_REGION=global (or specific region like us-east5)
  *
  * Authentication uses Google Cloud's default credential chain:
- * 1. GOOGLE_APPLICATION_CREDENTIALS (service account JSON)
- * 2. gcloud auth application-default login (ADC)
+ * 1. gcloud auth application-default login (recommended)
+ * 2. GOOGLE_APPLICATION_CREDENTIALS (service account JSON)
  * 3. GCE/GKE metadata service (when running on GCP)
  */
 
@@ -12,6 +19,7 @@ import { GoogleAuth } from 'google-auth-library';
 import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -129,23 +137,40 @@ type StreamEvent =
   | { type: 'message_stop' }
   | { type: 'ping' };
 
-export class VertexAIProvider implements LLMProvider {
-  readonly name = 'vertex-ai';
+export class AnthropicVertexProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'anthropic',
+    authMethod: 'vertex',
+    envVars: [
+      'CLAUDE_CODE_USE_VERTEX',
+      'ANTHROPIC_VERTEX_PROJECT_ID',
+      'CLOUD_ML_REGION',
+    ],
+    displayName: 'Google Vertex AI',
+    description: 'Claude via Google Cloud Platform',
+  };
+
+  readonly name = 'anthropic-vertex';
   private projectId: string;
   private region: string;
   private auth: GoogleAuth;
   private accessToken?: string;
 
   constructor(config: VertexAIConfig = {}) {
+    // Project ID priority (per Claude Code docs):
+    // 1. config.projectId
+    // 2. ANTHROPIC_VERTEX_PROJECT_ID
+    // 3. GCLOUD_PROJECT
+    // 4. GOOGLE_CLOUD_PROJECT
     this.projectId =
       config.projectId ??
       process.env.ANTHROPIC_VERTEX_PROJECT_ID ??
+      process.env.GCLOUD_PROJECT ??
       process.env.GOOGLE_CLOUD_PROJECT ??
       '';
 
     this.region =
       config.region ??
-      process.env.ANTHROPIC_VERTEX_REGION ??
       process.env.CLOUD_ML_REGION ??
       'us-east5';
 
@@ -153,7 +178,7 @@ export class VertexAIProvider implements LLMProvider {
 
     if (!this.projectId) {
       throw new Error(
-        'Vertex AI requires a project ID. Set ANTHROPIC_VERTEX_PROJECT_ID environment variable.'
+        'Vertex AI requires a project ID. Set one of: ANTHROPIC_VERTEX_PROJECT_ID, GCLOUD_PROJECT, or GOOGLE_CLOUD_PROJECT'
       );
     }
 
@@ -167,12 +192,23 @@ export class VertexAIProvider implements LLMProvider {
       return this.accessToken;
     }
 
-    const client = await this.auth.getClient();
-    const tokenResponse = await client.getAccessToken();
-    if (!tokenResponse.token) {
-      throw new Error('Failed to get access token from Google Cloud');
+    try {
+      const client = await this.auth.getClient();
+      const tokenResponse = await client.getAccessToken();
+      if (!tokenResponse.token) {
+        throw new Error('Failed to get access token from Google Cloud');
+      }
+      return tokenResponse.token;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to authenticate with Google Cloud. Please ensure you have:\n` +
+        `1. Run: gcloud auth application-default login\n` +
+        `2. Set ANTHROPIC_VERTEX_PROJECT_ID or GOOGLE_CLOUD_PROJECT\n` +
+        `3. Enabled Vertex AI API in your GCP project\n` +
+        `Original error: ${message}`
+      );
     }
-    return tokenResponse.token;
   }
 
   private getEndpoint(model: string, stream: boolean = false): string {