schrod-cli/src/services/aiService.ts

AI-driven application framework CLI that displays hierarchical Schrödinger project structure for systematic development workflow

import { AIProvider, ExecutionContext } from '../types';
import * as vscode from 'vscode';

export class AIService {
  private providers: Map<string, AIProvider> = new Map();

  constructor() {
    // Register default providers
    this.registerProvider(new ClaudeProvider());
    this.registerProvider(new GPTProvider());
  }

  registerProvider(provider: AIProvider): void {
    this.providers.set(provider.name, provider);
  }

  async getProvider(name: string): Promise<AIProvider | undefined> {
    const provider = this.providers.get(name);
    if (provider && await provider.isAvailable()) {
      return provider;
    }
    return undefined;
  }

  async execute(prompt: string, context: ExecutionContext): Promise<string> {
    const providerName = this.selectProvider(context);
    const provider = await this.getProvider(providerName);

    if (!provider) {
      throw new Error(`AI provider ${providerName} not available`);
    }

    return await provider.execute(prompt, context);
  }

  private selectProvider(context: ExecutionContext): string {
    const config = context.config;
    const nodePath = context.node.path;

    // Check for pattern-based overrides
    for (const [pattern, aiModel] of Object.entries(config.aiOverrides)) {
      if (this.matchesPattern(nodePath, pattern)) {
        return aiModel;
      }
    }

    return config.defaultAI;
  }

  private matchesPattern(path: string, pattern: string): boolean {
    // Convert glob pattern to regex
    const regex = pattern
      .replace(/\*\*/g, '.*')
      .replace(/\*/g, '[^/]*')
      .replace(/\?/g, '.');
    
    return new RegExp(`^${regex}$`).test(path);
  }
}

// Mock provider implementations
class ClaudeProvider implements AIProvider {
  name = 'claude-sonnet-4';

  async execute(_prompt: string, context: ExecutionContext): Promise<string> {
    // In real implementation, this would call Claude API
    vscode.window.showInformationMessage(`Executing with Claude: ${context.node.name}`);
    
    return `
// Generated by Claude
export function ${context.node.name}() {
  // TODO: Implement ${context.node.name}
  console.log('${context.node.name} executed');
}
    `.trim();
  }

  async isAvailable(): Promise<boolean> {
    // Check if API key is configured
    const config = vscode.workspace.getConfiguration('schrod');
    return !!config.get('claudeApiKey');
  }
}

class GPTProvider implements AIProvider {
  name = 'gpt-4';

  async execute(_prompt: string, context: ExecutionContext): Promise<string> {
    // In real implementation, this would call OpenAI API
    vscode.window.showInformationMessage(`Executing with GPT-4: ${context.node.name}`);
    
    return `
// Generated by GPT-4
export function ${context.node.name}() {
  // TODO: Implement ${context.node.name}
  console.log('${context.node.name} executed');
}
    `.trim();
  }

  async isAvailable(): Promise<boolean> {
    // Check if API key is configured
    const config = vscode.workspace.getConfiguration('schrod');
    return !!config.get('openaiApiKey');
  }
}