codex-linux 1.0.0

package/src/main/assistant/PredictedOutputManager.ts

@@ -0,0 +1,265 @@
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import log from 'electron-log';
+
+export interface Prediction {
+  id: string;
+  type: PredictionType;
+  confidence: number;
+  content: string;
+  reasoning?: string;
+  context: PredictionContext;
+  alternatives: PredictionAlternative[];
+  createdAt: Date;
+  usedAt?: Date;
+}
+
+export type PredictionType =
+  | 'code_completion'
+  | 'command_suggestion'
+  | 'file_action'
+  | 'refactoring'
+  | 'test_generation'
+  | 'documentation'
+  | 'error_fix'
+  | 'import_suggestion';
+
+export interface PredictionContext {
+  filePath?: string;
+  language?: string;
+  cursorPosition?: { line: number; column: number };
+  recentActions?: string[];
+  projectType?: string;
+}
+
+export interface PredictionAlternative {
+  content: string;
+  confidence: number;
+}
+
+export interface PredictionConfig {
+  maxPredictions: number;
+  confidenceThreshold: number;
+  predictionTimeout: number;
+  enableAlternatives: boolean;
+  contextWindowSize: number;
+}
+
+export class PredictedOutputManager extends EventEmitter {
+  private predictions: Map<string, Prediction> = new Map();
+  private config: PredictionConfig;
+  private contextHistory: PredictionContext[] = [];
+
+  constructor(config?: Partial<PredictionConfig>) {
+    super();
+    this.config = {
+      maxPredictions: config?.maxPredictions || 5,
+      confidenceThreshold: config?.confidenceThreshold || 0.7,
+      predictionTimeout: config?.predictionTimeout || 30000,
+      enableAlternatives: config?.enableAlternatives ?? true,
+      contextWindowSize: config?.contextWindowSize || 10,
+    };
+  }
+
+  configure(config: Partial<PredictionConfig>): void {
+    this.config = { ...this.config, ...config };
+    log.info('PredictedOutputManager configured', this.config);
+  }
+
+  getConfig(): PredictionConfig {
+    return { ...this.config };
+  }
+
+  addContext(context: PredictionContext): void {
+    this.contextHistory.push(context);
+    if (this.contextHistory.length > this.config.contextWindowSize) {
+      this.contextHistory.shift();
+    }
+    this.emit('context:added', context);
+  }
+
+  getRecentContext(): PredictionContext[] {
+    return [...this.contextHistory];
+  }
+
+  createPrediction(
+    type: PredictionType,
+    content: string,
+    context: PredictionContext,
+    options: {
+      confidence?: number;
+      reasoning?: string;
+      alternatives?: PredictionAlternative[];
+    } = {}
+  ): Prediction {
+    const prediction: Prediction = {
+      id: uuidv4(),
+      type,
+      confidence: options.confidence || 0.5,
+      content,
+      reasoning: options.reasoning,
+      context,
+      alternatives: options.alternatives || [],
+      createdAt: new Date(),
+    };
+
+    this.predictions.set(prediction.id, prediction);
+    this.emit('prediction:created', prediction);
+    log.debug(`Prediction created: ${type} (${prediction.confidence})`);
+
+    return prediction;
+  }
+
+  createPredictions(
+    type: PredictionType,
+    contents: string[],
+    context: PredictionContext,
+    options: {
+      reasoning?: string;
+    } = {}
+  ): Prediction[] {
+    const predictions: Prediction[] = [];
+
+    contents.forEach((content, index) => {
+      const confidence = 1.0 - index * 0.15;
+      const alternatives: PredictionAlternative[] = [];
+
+      if (this.config.enableAlternatives) {
+        contents.forEach((alt, altIndex) => {
+          if (altIndex !== index) {
+            alternatives.push({
+              content: alt,
+              confidence: 1.0 - altIndex * 0.15,
+            });
+          }
+        });
+      }
+
+      const prediction = this.createPrediction(type, content, context, {
+        confidence,
+        reasoning: options.reasoning,
+        alternatives: alternatives.slice(0, 3),
+      });
+
+      predictions.push(prediction);
+    });
+
+    return predictions;
+  }
+
+  getPrediction(id: string): Prediction | undefined {
+    return this.predictions.get(id);
+  }
+
+  getActivePredictions(): Prediction[] {
+    const now = new Date();
+    return Array.from(this.predictions.values())
+      .filter((p) => {
+        const age = now.getTime() - p.createdAt.getTime();
+        return age < this.config.predictionTimeout;
+      })
+      .sort((a, b) => b.confidence - a.confidence)
+      .slice(0, this.config.maxPredictions);
+  }
+
+  getPredictionsByType(type: PredictionType): Prediction[] {
+    return this.getActivePredictions().filter((p) => p.type === type);
+  }
+
+  markAsUsed(predictionId: string): boolean {
+    const prediction = this.predictions.get(predictionId);
+    if (!prediction) return false;
+
+    prediction.usedAt = new Date();
+    this.emit('prediction:used', prediction);
+    log.info(`Prediction used: ${prediction.type}`);
+    return true;
+  }
+
+  dismissPrediction(predictionId: string): boolean {
+    const prediction = this.predictions.get(predictionId);
+    if (!prediction) return false;
+
+    this.predictions.delete(predictionId);
+    this.emit('prediction:dismissed', prediction);
+    return true;
+  }
+
+  clearStalePredictions(): number {
+    const now = new Date();
+    let cleared = 0;
+
+    for (const [id, prediction] of this.predictions) {
+      const age = now.getTime() - prediction.createdAt.getTime();
+      if (age >= this.config.predictionTimeout) {
+        this.predictions.delete(id);
+        cleared++;
+      }
+    }
+
+    if (cleared > 0) {
+      log.debug(`Cleared ${cleared} stale predictions`);
+    }
+
+    return cleared;
+  }
+
+  getBestPrediction(type?: PredictionType): Prediction | null {
+    const predictions = type
+      ? this.getPredictionsByType(type)
+      : this.getActivePredictions();
+
+    const filtered = predictions.filter(
+      (p) => p.confidence >= this.config.confidenceThreshold
+    );
+
+    return filtered.length > 0 ? filtered[0] : null;
+  }
+
+  getStats(): {
+    totalPredictions: number;
+    activePredictions: number;
+    usedPredictions: number;
+    averageConfidence: number;
+    byType: Record<PredictionType, number>;
+  } {
+    const all = Array.from(this.predictions.values());
+    const active = this.getActivePredictions();
+    const used = all.filter((p) => p.usedAt !== undefined);
+
+    const byType: Record<PredictionType, number> = {
+      code_completion: 0,
+      command_suggestion: 0,
+      file_action: 0,
+      refactoring: 0,
+      test_generation: 0,
+      documentation: 0,
+      error_fix: 0,
+      import_suggestion: 0,
+    };
+
+    all.forEach((p) => {
+      byType[p.type]++;
+    });
+
+    return {
+      totalPredictions: all.length,
+      activePredictions: active.length,
+      usedPredictions: used.length,
+      averageConfidence:
+        active.length > 0
+          ? active.reduce((sum, p) => sum + p.confidence, 0) / active.length
+          : 0,
+      byType,
+    };
+  }
+
+  cleanup(): void {
+    this.predictions.clear();
+    this.contextHistory = [];
+    this.removeAllListeners();
+    log.info('PredictedOutputManager cleaned up');
+  }
+}
+
+export default PredictedOutputManager;

package/src/main/assistant/PromptCacheManager.ts

@@ -0,0 +1,280 @@
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import log from 'electron-log';
+import crypto from 'crypto';
+
+export interface CachedPrompt {
+  id: string;
+  name: string;
+  content: string;
+  contentHash: string;
+  systemPrompt?: string;
+  maxTokens: number;
+  temperature: number;
+  model: string;
+  useCount: number;
+  hitRate: number;
+  totalTokens: number;
+  cachedTokens: number;
+  lastUsed: Date;
+  createdAt: Date;
+  expiresAt?: Date;
+  metadata: Record<string, unknown>;
+}
+
+export interface PromptCacheConfig {
+  maxCacheSize: number;
+  maxCacheAge: number;
+  autoPrune: boolean;
+  enableHitRateTracking: boolean;
+}
+
+export interface CacheStats {
+  totalPrompts: number;
+  totalHits: number;
+  totalTokens: number;
+  cachedTokens: number;
+  averageHitRate: number;
+  cacheSize: number;
+}
+
+export class PromptCacheManager extends EventEmitter {
+  private cache: Map<string, CachedPrompt> = new Map();
+  private config: PromptCacheConfig;
+  private stats = {
+    totalHits: 0,
+    totalMisses: 0,
+    totalTokensSaved: 0,
+  };
+
+  constructor(config?: Partial<PromptCacheConfig>) {
+    super();
+    this.config = {
+      maxCacheSize: config?.maxCacheSize || 100,
+      maxCacheAge: config?.maxCacheAge || 7 * 24 * 60 * 60 * 1000,
+      autoPrune: config?.autoPrune ?? true,
+      enableHitRateTracking: config?.enableHitRateTracking ?? true,
+    };
+  }
+
+  configure(config: Partial<PromptCacheConfig>): void {
+    this.config = { ...this.config, ...config };
+    log.info('PromptCacheManager configured', this.config);
+  }
+
+  getConfig(): PromptCacheConfig {
+    return { ...this.config };
+  }
+
+  generateContentHash(content: string, systemPrompt?: string): string {
+    const combined = `${systemPrompt || ''}:${content}`;
+    return crypto.createHash('sha256').update(combined).digest('hex').substring(0, 16);
+  }
+
+  cachePrompt(
+    name: string,
+    content: string,
+    options: {
+      systemPrompt?: string;
+      maxTokens?: number;
+      temperature?: number;
+      model?: string;
+      expiresAt?: Date;
+      metadata?: Record<string, unknown>;
+    } = {}
+  ): CachedPrompt {
+    const contentHash = this.generateContentHash(content, options.systemPrompt);
+    const existing = Array.from(this.cache.values()).find(
+      (p) => p.contentHash === contentHash
+    );
+
+    if (existing) {
+      existing.useCount++;
+      existing.lastUsed = new Date();
+      this.emit('cache:hit', existing);
+      return existing;
+    }
+
+    if (this.cache.size >= this.config.maxCacheSize && this.config.autoPrune) {
+      this.prune();
+    }
+
+    const prompt: CachedPrompt = {
+      id: uuidv4(),
+      name,
+      content,
+      contentHash,
+      systemPrompt: options.systemPrompt,
+      maxTokens: options.maxTokens || 4096,
+      temperature: options.temperature || 0.7,
+      model: options.model || 'gpt-4o',
+      useCount: 1,
+      hitRate: 0,
+      totalTokens: 0,
+      cachedTokens: Math.ceil(content.split(' ').length / 0.75),
+      lastUsed: new Date(),
+      createdAt: new Date(),
+      expiresAt: options.expiresAt,
+      metadata: options.metadata || {},
+    };
+
+    this.cache.set(prompt.id, prompt);
+    this.emit('cache:stored', prompt);
+    log.info(`Prompt cached: ${name} (${contentHash})`);
+
+    return prompt;
+  }
+
+  getCachedPrompt(
+    content: string,
+    systemPrompt?: string
+  ): CachedPrompt | null {
+    const contentHash = this.generateContentHash(content, systemPrompt);
+    const prompt = Array.from(this.cache.values()).find(
+      (p) => p.contentHash === contentHash
+    );
+
+    if (prompt) {
+      if (prompt.expiresAt && prompt.expiresAt < new Date()) {
+        this.cache.delete(prompt.id);
+        this.emit('cache:expired', prompt);
+        return null;
+      }
+
+      prompt.useCount++;
+      prompt.lastUsed = new Date();
+      this.stats.totalHits++;
+      this.stats.totalTokensSaved += prompt.cachedTokens;
+      this.updateHitRate(prompt);
+      this.emit('cache:hit', prompt);
+      log.debug(`Cache hit: ${prompt.name}`);
+      return prompt;
+    }
+
+    this.stats.totalMisses++;
+    this.emit('cache:miss', { contentHash });
+    return null;
+  }
+
+  private updateHitRate(prompt: CachedPrompt): void {
+    if (this.config.enableHitRateTracking) {
+      const total = this.stats.totalHits + this.stats.totalMisses;
+      prompt.hitRate = total > 0 ? this.stats.totalHits / total : 0;
+    }
+  }
+
+  getPrompt(id: string): CachedPrompt | undefined {
+    return this.cache.get(id);
+  }
+
+  listPrompts(): CachedPrompt[] {
+    return Array.from(this.cache.values()).sort(
+      (a, b) => b.lastUsed.getTime() - a.lastUsed.getTime()
+    );
+  }
+
+  searchPrompts(query: string): CachedPrompt[] {
+    const lowerQuery = query.toLowerCase();
+    return this.listPrompts().filter(
+      (p) =>
+        p.name.toLowerCase().includes(lowerQuery) ||
+        p.content.toLowerCase().includes(lowerQuery) ||
+        p.systemPrompt?.toLowerCase().includes(lowerQuery)
+    );
+  }
+
+  updatePrompt(
+    id: string,
+    updates: Partial<Omit<CachedPrompt, 'id' | 'contentHash' | 'createdAt'>>
+  ): CachedPrompt | null {
+    const prompt = this.cache.get(id);
+    if (!prompt) return null;
+
+    Object.assign(prompt, updates, { lastUsed: new Date() });
+    this.emit('cache:updated', prompt);
+    return prompt;
+  }
+
+  deletePrompt(id: string): boolean {
+    const prompt = this.cache.get(id);
+    if (!prompt) return false;
+
+    this.cache.delete(id);
+    this.emit('cache:deleted', prompt);
+    log.info(`Prompt deleted: ${prompt.name}`);
+    return true;
+  }
+
+  prune(): number {
+    const now = new Date();
+    let pruned = 0;
+
+    for (const [id, prompt] of this.cache) {
+      const isExpired = prompt.expiresAt && prompt.expiresAt < now;
+      const isOld = now.getTime() - prompt.lastUsed.getTime() > this.config.maxCacheAge;
+      const isLowHitRate = prompt.hitRate < 0.1 && prompt.useCount > 10;
+
+      if (isExpired || (this.config.autoPrune && (isOld || isLowHitRate))) {
+        this.cache.delete(id);
+        pruned++;
+        this.emit('cache:pruned', prompt);
+      }
+    }
+
+    if (pruned > 0) {
+      log.info(`Pruned ${pruned} prompts from cache`);
+    }
+
+    return pruned;
+  }
+
+  clear(): void {
+    const count = this.cache.size;
+    this.cache.clear();
+    this.emit('cache:cleared', { count });
+    log.info(`Cleared ${count} cached prompts`);
+  }
+
+  getStats(): CacheStats {
+    const prompts = this.listPrompts();
+    const totalTokens = prompts.reduce((sum, p) => sum + p.totalTokens, 0);
+    const cachedTokens = prompts.reduce((sum, p) => sum + p.cachedTokens, 0);
+    const totalHits = prompts.reduce((sum, p) => sum + p.useCount, 0);
+
+    return {
+      totalPrompts: prompts.length,
+      totalHits,
+      totalTokens,
+      cachedTokens,
+      averageHitRate:
+        prompts.length > 0
+          ? prompts.reduce((sum, p) => sum + p.hitRate, 0) / prompts.length
+          : 0,
+      cacheSize: JSON.stringify(Array.from(this.cache.values())).length,
+    };
+  }
+
+  exportCache(): CachedPrompt[] {
+    return this.listPrompts();
+  }
+
+  importCache(prompts: CachedPrompt[]): number {
+    let imported = 0;
+    for (const prompt of prompts) {
+      if (!this.cache.has(prompt.id)) {
+        this.cache.set(prompt.id, prompt);
+        imported++;
+      }
+    }
+    log.info(`Imported ${imported} cached prompts`);
+    return imported;
+  }
+
+  cleanup(): void {
+    this.cache.clear();
+    this.removeAllListeners();
+    log.info('PromptCacheManager cleaned up');
+  }
+}
+
+export default PromptCacheManager;