gencode-ai 0.1.0 → 0.1.1

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

package/src/providers/search/serper.ts

@@ -0,0 +1,133 @@
+/**
+ * Serper.dev Search Provider
+ *
+ * Uses Google Search via Serper.dev API.
+ * Requires SERPER_API_KEY environment variable.
+ */
+
+import type { SearchProvider, SearchResult, SearchOptions } from './types.js';
+
+const API_CONFIG = {
+  BASE_URL: 'https://google.serper.dev',
+  ENDPOINT: '/search',
+  DEFAULT_NUM_RESULTS: 10,
+  DEFAULT_TIMEOUT: 10000,
+} as const;
+
+interface SerperRequest {
+  q: string;
+  num?: number;
+}
+
+interface SerperOrganicResult {
+  title: string;
+  link: string;
+  snippet: string;
+  position: number;
+}
+
+interface SerperResponse {
+  organic: SerperOrganicResult[];
+  searchParameters: {
+    q: string;
+    type: string;
+    num: number;
+  };
+}
+
+/**
+ * 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 SerperProvider implements SearchProvider {
+  readonly name = 'serper' as const;
+  private apiKey: string;
+
+  constructor(apiKey?: string) {
+    this.apiKey = apiKey ?? process.env.SERPER_API_KEY ?? '';
+    if (!this.apiKey) {
+      throw new Error('SERPER_API_KEY environment variable is required for Serper provider');
+    }
+  }
+
+  async search(query: string, options?: SearchOptions): Promise<SearchResult[]> {
+    const searchRequest: SerperRequest = {
+      q: query,
+      num: 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}`, {
+        method: 'POST',
+        headers: {
+          'X-API-KEY': this.apiKey,
+          '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(`Serper search error (${response.status}): ${errorText}`);
+      }
+
+      const data = await response.json() as SerperResponse;
+
+      const results: SearchResult[] = (data.organic || []).map((item) => ({
+        title: item.title,
+        url: item.link,
+        snippet: item.snippet,
+      }));
+
+      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/types.ts

@@ -0,0 +1,24 @@
+/**
+ * Search Provider Types
+ */
+
+export type SearchProviderName = 'exa' | 'serper' | 'brave';
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+export interface SearchOptions {
+  numResults?: number;
+  allowedDomains?: string[];
+  blockedDomains?: string[];
+  timeout?: number;
+  abortSignal?: AbortSignal;
+}
+
+export interface SearchProvider {
+  readonly name: SearchProviderName;
+  search(query: string, options?: SearchOptions): Promise<SearchResult[]>;
+}

package/src/providers/store.ts

@@ -0,0 +1,216 @@
+/**
+ * Provider Store - Manages provider connections and model cache
+ *
+ * Storage location: ~/.gencode/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 { SearchProviderName } from './search/types.js';
+
+export interface ModelInfo {
+  id: string;
+  name: string;
+}
+
+export interface ProviderConnection {
+  method: string;
+  connectedAt: string;
+}
+
+export interface ModelCache {
+  cachedAt: string;
+  list: ModelInfo[];
+}
+
+export interface ProvidersConfig {
+  connections: Record<string, ProviderConnection>;
+  models: Record<string, ModelCache>;
+  searchProvider?: SearchProviderName;
+}
+
+const CONFIG_DIR = join(homedir(), '.gencode');
+const CONFIG_FILE = join(CONFIG_DIR, 'providers.json');
+
+/**
+ * Provider Store - manages connection state and model cache
+ */
+export class ProviderStore {
+  private config: ProvidersConfig;
+
+  constructor() {
+    this.config = this.load();
+  }
+
+  /**
+   * Load configuration from disk
+   */
+  private load(): ProvidersConfig {
+    try {
+      if (existsSync(CONFIG_FILE)) {
+        const data = readFileSync(CONFIG_FILE, 'utf-8');
+        return JSON.parse(data);
+      }
+    } catch {
+      // Ignore parse errors, start fresh
+    }
+    return { connections: {}, models: {} };
+  }
+
+  /**
+   * Save configuration to disk
+   */
+  private save(): void {
+    try {
+      if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+      }
+      writeFileSync(CONFIG_FILE, JSON.stringify(this.config, null, 2));
+    } catch {
+      // Silently fail if we can't write
+    }
+  }
+
+  /**
+   * Check if a provider is connected
+   */
+  isConnected(providerId: ProviderName): boolean {
+    return !!this.config.connections[providerId];
+  }
+
+  /**
+   * Get connection info for a provider
+   */
+  getConnection(providerId: ProviderName): ProviderConnection | undefined {
+    return this.config.connections[providerId];
+  }
+
+  /**
+   * Get all connected provider IDs
+   */
+  getConnectedProviders(): ProviderName[] {
+    return Object.keys(this.config.connections) as ProviderName[];
+  }
+
+  /**
+   * Connect a provider
+   */
+  connect(providerId: ProviderName, method: string): void {
+    this.config.connections[providerId] = {
+      method,
+      connectedAt: new Date().toISOString(),
+    };
+    this.save();
+  }
+
+  /**
+   * Disconnect a provider
+   */
+  disconnect(providerId: ProviderName): void {
+    delete this.config.connections[providerId];
+    delete this.config.models[providerId];
+    this.save();
+  }
+
+  /**
+   * Get cached models for a provider
+   */
+  getModels(providerId: ProviderName): ModelInfo[] {
+    return this.config.models[providerId]?.list ?? [];
+  }
+
+  /**
+   * Get all cached models grouped by provider
+   */
+  getAllModels(): Record<ProviderName, 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[]>;
+  }
+
+  /**
+   * Cache models for a provider
+   */
+  cacheModels(providerId: ProviderName, models: ModelInfo[]): void {
+    this.config.models[providerId] = {
+      cachedAt: new Date().toISOString(),
+      list: models,
+    };
+    this.save();
+  }
+
+  /**
+   * Get cache timestamp for a provider
+   */
+  getCacheTime(providerId: ProviderName): Date | undefined {
+    const cache = this.config.models[providerId];
+    return cache ? new Date(cache.cachedAt) : undefined;
+  }
+
+  /**
+   * Check if model cache is stale (older than 24 hours)
+   */
+  isCacheStale(providerId: ProviderName): boolean {
+    const cacheTime = this.getCacheTime(providerId);
+    if (!cacheTime) return true;
+    const hoursSinceCache = (Date.now() - cacheTime.getTime()) / (1000 * 60 * 60);
+    return hoursSinceCache > 24;
+  }
+
+  /**
+   * Get total model count across all connected providers
+   */
+  getTotalModelCount(): number {
+    return Object.values(this.config.models).reduce(
+      (sum, cache) => sum + cache.list.length,
+      0
+    );
+  }
+
+  /**
+   * Get model count for a specific provider
+   */
+  getModelCount(providerId: ProviderName): number {
+    return this.config.models[providerId]?.list.length ?? 0;
+  }
+
+  /**
+   * Get the configured search provider
+   */
+  getSearchProvider(): SearchProviderName | undefined {
+    return this.config.searchProvider;
+  }
+
+  /**
+   * Set the search provider
+   */
+  setSearchProvider(id: SearchProviderName): void {
+    this.config.searchProvider = id;
+    this.save();
+  }
+
+  /**
+   * Clear the search provider (use default)
+   */
+  clearSearchProvider(): void {
+    delete this.config.searchProvider;
+    this.save();
+  }
+}
+
+// Singleton instance
+let storeInstance: ProviderStore | null = null;
+
+/**
+ * Get the singleton provider store instance
+ */
+export function getProviderStore(): ProviderStore {
+  if (!storeInstance) {
+    storeInstance = new ProviderStore();
+  }
+  return storeInstance;
+}

package/src/providers/types.ts

@@ -19,6 +19,8 @@ export interface ToolUseContent {
   id: string;
   name: string;
   input: Record<string, unknown>;
+  // Gemini 3+ thought signature for maintaining reasoning chain
+  thoughtSignature?: string;
 }
 
 export interface ToolResultContent {
@@ -178,4 +180,10 @@ export interface GeminiConfig {
   apiKey?: string;
 }
 
-export type ProviderConfig = OpenAIConfig | AnthropicConfig | GeminiConfig;
+export interface VertexAIConfig {
+  projectId?: string;
+  region?: string;
+  accessToken?: string;
+}
+
+export type ProviderConfig = OpenAIConfig | AnthropicConfig | GeminiConfig | VertexAIConfig;