gencode-ai 0.1.0 → 0.1.2

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

package/src/providers/search/exa.ts

@@ -0,0 +1,217 @@
+/**
+ * Exa AI Search Provider
+ *
+ * Uses Exa's public MCP endpoint (no API key required).
+ * Based on OpenCode's implementation pattern.
+ */
+
+import type { SearchProvider, SearchResult, SearchOptions } from './types.js';
+
+const API_CONFIG = {
+  BASE_URL: 'https://mcp.exa.ai',
+  ENDPOINT: '/mcp',
+  DEFAULT_NUM_RESULTS: 8,
+  DEFAULT_TIMEOUT: 25000,
+} as const;
+
+interface McpSearchRequest {
+  jsonrpc: string;
+  id: number;
+  method: string;
+  params: {
+    name: string;
+    arguments: {
+      query: string;
+      numResults?: number;
+      livecrawl?: 'fallback' | 'preferred';
+      type?: 'auto' | 'fast' | 'deep';
+      contextMaxCharacters?: number;
+    };
+  };
+}
+
+interface McpSearchResponse {
+  jsonrpc: string;
+  result: {
+    content: Array<{
+      type: string;
+      text: string;
+    }>;
+  };
+}
+
+/**
+ * Parse Exa's response text into structured search results
+ *
+ * Exa returns results in this format:
+ * Title: ...
+ * URL: ...
+ * Text: ...
+ */
+function parseExaResults(text: string): SearchResult[] {
+  const results: SearchResult[] = [];
+  const lines = text.split('\n');
+
+  let currentResult: Partial<SearchResult> = {};
+  let collectingText = false;
+  let textBuffer: string[] = [];
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+
+    // Check for "Title: ..." line
+    if (trimmed.startsWith('Title:')) {
+      // Save previous result if exists
+      if (currentResult.title && currentResult.url) {
+        results.push({
+          title: currentResult.title,
+          url: currentResult.url,
+          snippet: textBuffer.join(' ').trim().substring(0, 300),
+        });
+      }
+      currentResult = { title: trimmed.substring(6).trim() };
+      collectingText = false;
+      textBuffer = [];
+      continue;
+    }
+
+    // Check for "URL: ..." line
+    if (trimmed.startsWith('URL:')) {
+      currentResult.url = trimmed.substring(4).trim();
+      continue;
+    }
+
+    // Check for "Text: ..." line - start of snippet
+    if (trimmed.startsWith('Text:')) {
+      collectingText = true;
+      const initialText = trimmed.substring(5).trim();
+      if (initialText) {
+        textBuffer.push(initialText);
+      }
+      continue;
+    }
+
+    // Collect text lines until next Title
+    if (collectingText && trimmed && !trimmed.startsWith('Title:')) {
+      textBuffer.push(trimmed);
+    }
+  }
+
+  // Add the last result
+  if (currentResult.title && currentResult.url) {
+    results.push({
+      title: currentResult.title,
+      url: currentResult.url,
+      snippet: textBuffer.join(' ').trim().substring(0, 300),
+    });
+  }
+
+  return results;
+}
+
+/**
+ * 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 ExaProvider implements SearchProvider {
+  readonly name = 'exa' as const;
+
+  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const searchRequest: McpSearchRequest = {
+      jsonrpc: '2.0',
+      id: 1,
+      method: 'tools/call',
+      params: {
+        name: 'web_search_exa',
+        arguments: {
+          query,
+          type: 'auto',
+          numResults: options?.numResults ?? API_CONFIG.DEFAULT_NUM_RESULTS,
+          livecrawl: 'fallback',
+          contextMaxCharacters: 10000,
+        },
+      },
+    };
+
+    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}`, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json, text/event-stream',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(searchRequest),
+        signal: AbortSignal.any(signals),
+      });
+
+      clearTimeout(timeoutId);
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Exa search error (${response.status}): ${errorText}`);
+      }
+
+      const responseText = await response.text();
+
+      // Parse SSE response
+      const lines = responseText.split('\n');
+      for (const line of lines) {
+        if (line.startsWith('data: ')) {
+          const data: McpSearchResponse = JSON.parse(line.substring(6));
+          if (data.result?.content?.length > 0) {
+            const text = data.result.content[0].text;
+            const results = parseExaResults(text);
+            return filterByDomain(results, options);
+          }
+        }
+      }
+
+      return [];
+    } catch (error) {
+      clearTimeout(timeoutId);
+
+      if (error instanceof Error && error.name === 'AbortError') {
+        throw new Error('Search request timed out');
+      }
+
+      throw error;
+    }
+  }
+}

package/src/providers/search/index.ts

@@ -0,0 +1,79 @@
+/**
+ * Search Providers - Factory and exports
+ */
+
+export * from './types.js';
+export { ExaProvider } from './exa.js';
+export { SerperProvider } from './serper.js';
+export { BraveProvider } from './brave.js';
+
+import type { SearchProvider, SearchProviderName } from './types.js';
+import { ExaProvider } from './exa.js';
+import { SerperProvider } from './serper.js';
+import { BraveProvider } from './brave.js';
+import { getProviderStore } from '../store.js';
+
+/**
+ * Detect search provider from environment variables
+ */
+function detectFromEnv(): SearchProviderName | undefined {
+  if (process.env.SERPER_API_KEY) return 'serper';
+  if (process.env.BRAVE_API_KEY) return 'brave';
+  return undefined;
+}
+
+/**
+ * Create a search provider instance
+ *
+ * Priority:
+ * 1. Explicit name parameter
+ * 2. Configured in provider store
+ * 3. Detected from environment variables
+ * 4. Default: Exa (no key required)
+ */
+export function createSearchProvider(name?: SearchProviderName): SearchProvider {
+  const providerName = name ?? getProviderStore().getSearchProvider() ?? detectFromEnv() ?? 'exa';
+
+  switch (providerName) {
+    case 'serper':
+      return new SerperProvider();
+    case 'brave':
+      return new BraveProvider();
+    case 'exa':
+    default:
+      return new ExaProvider();
+  }
+}
+
+/**
+ * Get the name of the current search provider
+ */
+export function getCurrentSearchProviderName(): SearchProviderName {
+  return getProviderStore().getSearchProvider() ?? detectFromEnv() ?? 'exa';
+}
+
+/**
+ * Check if a search provider is available (has required API keys)
+ */
+export function isSearchProviderAvailable(name: SearchProviderName): boolean {
+  switch (name) {
+    case 'exa':
+      return true; // Always available
+    case 'serper':
+      return !!process.env.SERPER_API_KEY;
+    case 'brave':
+      return !!process.env.BRAVE_API_KEY;
+    default:
+      return false;
+  }
+}
+
+/**
+ * Get all available search providers
+ */
+export function getAvailableSearchProviders(): SearchProviderName[] {
+  const providers: SearchProviderName[] = ['exa']; // Always available
+  if (process.env.SERPER_API_KEY) providers.push('serper');
+  if (process.env.BRAVE_API_KEY) providers.push('brave');
+  return providers;
+}