codex-linux 1.0.0

package/src/main/agents/CodeIndex.ts

@@ -0,0 +1,240 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import crypto from 'crypto';
+import log from 'electron-log';
+import { EmbeddingService } from './EmbeddingService';
+
+interface CodeIndexEntry {
+  id: string;
+  filePath: string;
+  content: string;
+  chunkStart: number;
+  chunkEnd: number;
+  embedding?: number[];
+  lastModified: number;
+}
+
+interface SearchResult {
+  filePath: string;
+  chunkStart: number;
+  chunkEnd: number;
+  content: string;
+  similarity: number;
+}
+
+export class CodeIndex {
+  private indexPath: string;
+  private entries: Map<string, CodeIndexEntry> = new Map();
+  private worktreePath: string;
+  private embeddingService: EmbeddingService | null = null;
+
+  constructor(worktreePath: string, indexDir: string = '.codex/index', apiKey?: string) {
+    this.worktreePath = worktreePath;
+    this.indexPath = path.join(worktreePath, indexDir, 'code-index.json');
+    if (apiKey) {
+      this.embeddingService = new EmbeddingService(apiKey);
+    }
+  }
+
+  async initialize(): Promise<void> {
+    try {
+      await fs.mkdir(path.dirname(this.indexPath), { recursive: true });
+      const content = await fs.readFile(this.indexPath, 'utf-8');
+      const data = JSON.parse(content);
+      for (const entry of data.entries || []) {
+        this.entries.set(entry.id, entry);
+      }
+      log.info(`Loaded code index with ${this.entries.size} entries`);
+    } catch {
+      log.info('No existing code index, starting fresh');
+    }
+  }
+
+  async save(): Promise<void> {
+    const data = {
+      entries: Array.from(this.entries.values()),
+      updatedAt: Date.now()
+    };
+    await fs.writeFile(this.indexPath, JSON.stringify(data, null, 2), 'utf-8');
+  }
+
+  async indexFile(filePath: string): Promise<void> {
+    const fullPath = path.join(this.worktreePath, filePath);
+    
+    try {
+      const stats = await fs.stat(fullPath);
+      const content = await fs.readFile(fullPath, 'utf-8');
+      
+      // Split into chunks of ~100 lines
+      const lines = content.split('\n');
+      const chunkSize = 100;
+      
+      for (let i = 0; i < lines.length; i += chunkSize) {
+        const chunkStart = i;
+        const chunkEnd = Math.min(i + chunkSize, lines.length);
+        const chunkContent = lines.slice(chunkStart, chunkEnd).join('\n');
+        
+        const id = crypto.createHash('md5').update(`${filePath}:${chunkStart}`).digest('hex');
+        
+        // Use real OpenAI embeddings if available, otherwise fallback to simple
+        let embedding: number[];
+        if (this.embeddingService?.isAvailable()) {
+          try {
+            embedding = await this.embeddingService.createEmbedding(chunkContent);
+          } catch {
+            // Fallback to simple embedding if OpenAI fails
+            embedding = this.computeSimpleEmbedding(chunkContent);
+          }
+        } else {
+          embedding = this.computeSimpleEmbedding(chunkContent);
+        }
+        
+        this.entries.set(id, {
+          id,
+          filePath,
+          content: chunkContent,
+          chunkStart,
+          chunkEnd,
+          embedding,
+          lastModified: stats.mtimeMs
+        });
+      }
+      
+      log.info(`Indexed ${filePath}: ${Math.ceil(lines.length / chunkSize)} chunks`);
+    } catch (error) {
+      log.warn(`Failed to index ${filePath}:`, error);
+    }
+  }
+
+  private computeSimpleEmbedding(content: string): number[] {
+    // Simple feature extraction for similarity
+    // In production, you'd use a real embedding model like OpenAI's text-embedding-3-small
+    const features: number[] = [];
+    
+    // Length feature
+    features.push(content.length / 1000);
+    
+    // Character distribution (simplified)
+    const chars = content.toLowerCase();
+    const total = chars.length || 1;
+    
+    // Code-specific features
+    features.push((chars.match(/function|def|class|const|let|var/g) || []).length / total * 10);
+    features.push((chars.match(/import|require|from/g) || []).length / total * 10);
+    features.push((chars.match(/return|await|async/g) || []).length / total * 10);
+    features.push((chars.match(/if|for|while|switch/g) || []).length / total * 10);
+    
+    // Comment density
+    features.push((chars.match(/\/\/|\/\*|#/g) || []).length / total * 10);
+    
+    // Pad to fixed size
+    while (features.length < 8) features.push(0);
+    
+    return features.slice(0, 8);
+  }
+
+  private cosineSimilarity(a: number[], b: number[]): number {
+    // Use EmbeddingService's implementation for consistency
+    return EmbeddingService.cosineSimilarity(a, b);
+  }
+
+  async search(query: string, limit: number = 5): Promise<SearchResult[]> {
+    // Compute query embedding
+    let queryEmbedding: number[];
+    if (this.embeddingService?.isAvailable()) {
+      try {
+        queryEmbedding = await this.embeddingService.createEmbedding(query);
+      } catch {
+        queryEmbedding = this.computeSimpleEmbedding(query);
+      }
+    } else {
+      queryEmbedding = this.computeSimpleEmbedding(query);
+    }
+    
+    // Score all entries
+    const scored: SearchResult[] = [];
+    
+    for (const entry of this.entries.values()) {
+      if (!entry.embedding) continue;
+      
+      const similarity = EmbeddingService.cosineSimilarity(queryEmbedding, entry.embedding);
+      
+      // Boost for exact keyword matches
+      const keywords = query.toLowerCase().split(/\s+/);
+      const contentLower = entry.content.toLowerCase();
+      const keywordMatches = keywords.filter(kw => contentLower.includes(kw)).length;
+      const boostedSimilarity = similarity + (keywordMatches / keywords.length) * 0.3;
+      
+      if (boostedSimilarity > 0.1) {
+        scored.push({
+          filePath: entry.filePath,
+          chunkStart: entry.chunkStart,
+          chunkEnd: entry.chunkEnd,
+          content: entry.content,
+          similarity: boostedSimilarity
+        });
+      }
+    }
+    
+    // Sort by similarity and return top results
+    scored.sort((a, b) => b.similarity - a.similarity);
+    
+    return scored.slice(0, limit);
+  }
+
+  async indexProject(): Promise<void> {
+    log.info('Starting project indexing...');
+    
+    const extensions = ['.ts', '.tsx', '.js', '.jsx', '.py', '.java', '.go', '.rs', '.md'];
+    
+    async function walk(dir: string): Promise<string[]> {
+      const files: string[] = [];
+      
+      try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          const relativePath = path.relative(worktreePath, fullPath);
+          
+          if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && 
+                entry.name !== 'node_modules' && 
+                entry.name !== 'dist' && 
+                entry.name !== 'build') {
+              files.push(...await walk(fullPath));
+            }
+          } else if (entry.isFile()) {
+            if (extensions.some(ext => entry.name.endsWith(ext))) {
+              files.push(relativePath);
+            }
+          }
+        }
+      } catch (error) {
+        // Skip inaccessible directories
+      }
+      
+      return files;
+    }
+    
+    const worktreePath = this.worktreePath;
+    const allFiles = await walk(worktreePath);
+    
+    log.info(`Found ${allFiles.length} files to index`);
+    
+    for (const file of allFiles.slice(0, 100)) { // Limit to 100 files for now
+      await this.indexFile(file);
+    }
+    
+    await this.save();
+    log.info(`Indexed ${this.entries.size} chunks`);
+  }
+
+  getIndexedFiles(): string[] {
+    const files = new Set<string>();
+    for (const entry of this.entries.values()) {
+      files.add(entry.filePath);
+    }
+    return Array.from(files);
+  }
+}

package/src/main/agents/EmbeddingService.ts

@@ -0,0 +1,88 @@
+import OpenAI from 'openai';
+import log from 'electron-log';
+
+export interface EmbeddingResult {
+  embedding: number[];
+  index: number;
+}
+
+export class EmbeddingService {
+  private client: OpenAI | null = null;
+  private model: string = 'text-embedding-3-small';
+
+  constructor(apiKey?: string) {
+    if (apiKey) {
+      this.client = new OpenAI({
+        apiKey,
+        timeout: 30000,
+        maxRetries: 3
+      });
+    }
+  }
+
+  async createEmbedding(text: string): Promise<number[]> {
+    if (!this.client) {
+      throw new Error('OpenAI client not initialized - no API key');
+    }
+
+    try {
+      // Truncate if too long (max ~8000 tokens for embedding-3)
+      const truncatedText = text.length > 30000 ? text.slice(0, 30000) : text;
+
+      const response = await this.client.embeddings.create({
+        model: this.model,
+        input: truncatedText,
+        encoding_format: 'float'
+      });
+
+      return response.data[0].embedding;
+    } catch (error) {
+      log.error('Failed to create embedding:', error);
+      throw error;
+    }
+  }
+
+  async createEmbeddings(texts: string[]): Promise<EmbeddingResult[]> {
+    if (!this.client) {
+      throw new Error('OpenAI client not initialized - no API key');
+    }
+
+    try {
+      // Truncate texts if too long
+      const truncatedTexts = texts.map(t => t.length > 30000 ? t.slice(0, 30000) : t);
+
+      const response = await this.client.embeddings.create({
+        model: this.model,
+        input: truncatedTexts,
+        encoding_format: 'float'
+      });
+
+      return response.data.map(d => ({
+        embedding: d.embedding,
+        index: d.index
+      }));
+    } catch (error) {
+      log.error('Failed to create embeddings:', error);
+      throw error;
+    }
+  }
+
+  static cosineSimilarity(a: number[], b: number[]): number {
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+
+    if (normA === 0 || normB === 0) return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+  }
+
+  isAvailable(): boolean {
+    return this.client !== null;
+  }
+}

package/src/main/agents/NativeToolCalling.ts

@@ -0,0 +1,245 @@
+import OpenAI from 'openai';
+import log from 'electron-log';
+import { AgentTools, ToolResult } from './AgentTools';
+
+interface ToolCall {
+  id: string;
+  type: 'function';
+  function: {
+    name: string;
+    arguments: string;
+  };
+}
+
+interface ToolDefinition {
+  type: 'function';
+  function: {
+    name: string;
+    description: string;
+    parameters: {
+      type: 'object';
+      properties: Record<string, any>;
+      required?: string[];
+    };
+  };
+}
+
+export class NativeToolCalling {
+  private client: OpenAI | null = null;
+  private tools: AgentTools;
+  private toolDefinitions: ToolDefinition[];
+
+  constructor(apiKey: string | undefined, worktreePath: string) {
+    if (apiKey) {
+      this.client = new OpenAI({
+        apiKey,
+        timeout: 60000,
+        maxRetries: 3
+      });
+    }
+    this.tools = new AgentTools(worktreePath);
+    this.toolDefinitions = this.buildToolDefinitions();
+  }
+
+  private buildToolDefinitions(): ToolDefinition[] {
+    return [
+      {
+        type: 'function',
+        function: {
+          name: 'view',
+          description: 'View the contents of a file. Use offset and limit for large files.',
+          parameters: {
+            type: 'object',
+            properties: {
+              file_path: { type: 'string', description: 'Path to the file' },
+              offset: { type: 'number', description: 'Start line number (1-based)' },
+              limit: { type: 'number', description: 'Number of lines to show (max 200)' }
+            },
+            required: ['file_path']
+          }
+        }
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'edit',
+          description: 'Edit a file by replacing a specific string. The old_string must match exactly and uniquely.',
+          parameters: {
+            type: 'object',
+            properties: {
+              file_path: { type: 'string', description: 'Path to the file' },
+              old_string: { type: 'string', description: 'Exact string to replace' },
+              new_string: { type: 'string', description: 'Replacement string' }
+            },
+            required: ['file_path', 'old_string', 'new_string']
+          }
+        }
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'bash',
+          description: 'Execute a bash command in the worktree. Use for running tests, builds, git commands, etc.',
+          parameters: {
+            type: 'object',
+            properties: {
+              command: { type: 'string', description: 'Command to execute' },
+              timeout: { type: 'number', description: 'Timeout in milliseconds (default 120000)' }
+            },
+            required: ['command']
+          }
+        }
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'glob',
+          description: 'Find files matching a glob pattern (e.g., "**/*.ts").',
+          parameters: {
+            type: 'object',
+            properties: {
+              pattern: { type: 'string', description: 'Glob pattern' },
+              path: { type: 'string', description: 'Directory to search in' }
+            },
+            required: ['pattern']
+          }
+        }
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'grep',
+          description: 'Search for a pattern in file contents using grep.',
+          parameters: {
+            type: 'object',
+            properties: {
+              pattern: { type: 'string', description: 'Search pattern' },
+              path: { type: 'string', description: 'Directory to search in' },
+              include: { type: 'string', description: 'File pattern to include (e.g., "*.ts")' }
+            },
+            required: ['pattern']
+          }
+        }
+      },
+      {
+        type: 'function',
+        function: {
+          name: 'ls',
+          description: 'List the contents of a directory.',
+          parameters: {
+            type: 'object',
+            properties: {
+              path: { type: 'string', description: 'Directory path' }
+            },
+            required: ['path']
+          }
+        }
+      }
+    ];
+  }
+
+  isAvailable(): boolean {
+    return this.client !== null;
+  }
+
+  async executeWithTools(
+    model: string,
+    systemPrompt: string,
+    userPrompt: string,
+    onToolCall?: (toolCall: ToolCall, result: ToolResult) => void
+  ): Promise<string> {
+    if (!this.client) {
+      throw new Error('OpenAI client not initialized');
+    }
+
+    const messages: any[] = [
+      { role: 'system', content: systemPrompt },
+      { role: 'user', content: userPrompt }
+    ];
+
+    let iterations = 0;
+    const maxIterations = 20;
+
+    while (iterations < maxIterations) {
+      iterations++;
+      
+      log.info(`Tool calling iteration ${iterations}`);
+
+      const response = await this.client.chat.completions.create({
+        model,
+        messages,
+        tools: this.toolDefinitions,
+        tool_choice: 'auto',
+        max_tokens: 4096
+      });
+
+      const message = response.choices[0].message;
+
+      // If no tool calls, we're done
+      if (!message.tool_calls || message.tool_calls.length === 0) {
+        return message.content || '';
+      }
+
+      // Add assistant message with tool calls
+      messages.push(message);
+
+      // Execute each tool call
+      for (const toolCall of message.tool_calls) {
+        const result = await this.executeToolCall(toolCall);
+        
+        if (onToolCall) {
+          onToolCall(toolCall as ToolCall, result);
+        }
+
+        // Add tool result to messages
+        messages.push({
+          role: 'tool',
+          tool_call_id: toolCall.id,
+          content: result.success 
+            ? result.output 
+            : `Error: ${result.error || 'Unknown error'}`
+        });
+      }
+    }
+
+    throw new Error(`Max iterations (${maxIterations}) reached`);
+  }
+
+  private async executeToolCall(toolCall: any): Promise<ToolResult> {
+    const { name, arguments: argsString } = toolCall.function;
+    
+    try {
+      const args = JSON.parse(argsString);
+      
+      log.info(`Executing tool: ${name}`, args);
+
+      switch (name) {
+        case 'view':
+          return await this.tools.view(args);
+        case 'edit':
+          return await this.tools.edit(args);
+        case 'bash':
+          return await this.tools.bash(args);
+        case 'glob':
+          return await this.tools.glob(args);
+        case 'grep':
+          return await this.tools.grep(args);
+        case 'ls':
+          return await this.tools.ls(args);
+        default:
+          return {
+            success: false,
+            output: '',
+            error: `Unknown tool: ${name}`
+          };
+      }
+    } catch (error) {
+      log.error(`Failed to execute tool ${name}:`, error);
+      return {
+        success: false,
+        output: '',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+}