gencode-ai 0.1.0 → 0.1.2

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;