promptarchitect 0.6.0

package/src/agentService.ts

@@ -0,0 +1,630 @@
+/**
+ * Agent Service
+ *
+ * Powers the AI agent capabilities within VS Code.
+ * Handles tool composition, workspace context, and autonomous actions.
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import { PromptArchitectAPI } from './api';
+import { WorkspaceIndexer } from './workspaceIndexer';
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface AgentAction {
+  type: 'read_file' | 'write_file' | 'execute_command' | 'search_files' |
+        'insert_code' | 'open_file' | 'refine_prompt' | 'generate_prompt' |
+        'run_test' | 'install_package' | 'git_status';
+  params: Record<string, any>;
+  description: string;
+}
+
+export interface AgentResponse {
+  message: string;
+  actions?: AgentAction[];
+  suggestions?: string[];
+  codeBlocks?: CodeBlock[];
+  workspaceAware?: boolean;
+}
+
+export interface CodeBlock {
+  language: string;
+  code: string;
+  filename?: string;
+  action?: 'insert' | 'replace' | 'create';
+}
+
+export interface WorkspaceContext {
+  name: string;
+  techStack: string[];
+  dependencies: Record<string, string>;
+  structure: string[];
+  currentFile?: {
+    path: string;
+    language: string;
+    content?: string;
+    selection?: string;
+  };
+  recentFiles: string[];
+  gitStatus?: string;
+}
+
+export interface AgentConfig {
+  autoInjectContext: boolean;
+  proactiveRefine: boolean;
+  suggestActions: boolean;
+  streamResponses: boolean;
+}
+
+// ============================================================================
+// AGENT SERVICE
+// ============================================================================
+
+export class AgentService {
+  private context: vscode.ExtensionContext;
+  private api: PromptArchitectAPI;
+  private workspaceIndexer: WorkspaceIndexer;
+  private config: AgentConfig;
+  private recentFiles: string[] = [];
+  private static instance: AgentService;
+
+  private constructor(
+    context: vscode.ExtensionContext,
+    api: PromptArchitectAPI,
+    workspaceIndexer: WorkspaceIndexer
+  ) {
+    this.context = context;
+    this.api = api;
+    this.workspaceIndexer = workspaceIndexer;
+    this.config = this.loadConfig();
+
+    // Track file opens
+    this.setupFileTracking();
+  }
+
+  static getInstance(
+    context: vscode.ExtensionContext,
+    api: PromptArchitectAPI,
+    workspaceIndexer: WorkspaceIndexer
+  ): AgentService {
+    if (!AgentService.instance) {
+      AgentService.instance = new AgentService(context, api, workspaceIndexer);
+    }
+    return AgentService.instance;
+  }
+
+  private loadConfig(): AgentConfig {
+    const vsConfig = vscode.workspace.getConfiguration('promptarchitect');
+    return {
+      autoInjectContext: vsConfig.get<boolean>('autoInjectContext', true),
+      proactiveRefine: vsConfig.get<boolean>('proactiveRefine', false),
+      suggestActions: vsConfig.get<boolean>('suggestActions', true),
+      streamResponses: vsConfig.get<boolean>('streamResponses', true),
+    };
+  }
+
+  private setupFileTracking() {
+    vscode.window.onDidChangeActiveTextEditor((editor) => {
+      if (editor) {
+        const filePath = editor.document.uri.fsPath;
+        this.recentFiles = [
+          filePath,
+          ...this.recentFiles.filter(f => f !== filePath).slice(0, 9)
+        ];
+      }
+    });
+  }
+
+  // ============================================================================
+  // WORKSPACE CONTEXT
+  // ============================================================================
+
+  /**
+   * Get comprehensive workspace context for agent operations
+   */
+  async getWorkspaceContext(): Promise<WorkspaceContext> {
+    const workspaceFolder = vscode.workspace.workspaceFolders?.[0];
+    const workspaceName = workspaceFolder?.name || 'Unknown';
+    const workspacePath = workspaceFolder?.uri.fsPath || '';
+
+    // Get indexed data
+    const index = this.workspaceIndexer.getIndex();
+
+    // Get current file context
+    const editor = vscode.window.activeTextEditor;
+    let currentFile: WorkspaceContext['currentFile'];
+
+    if (editor) {
+      currentFile = {
+        path: path.relative(workspacePath, editor.document.uri.fsPath),
+        language: editor.document.languageId,
+      };
+
+      // Include selection if any
+      if (!editor.selection.isEmpty) {
+        currentFile.selection = editor.document.getText(editor.selection);
+      }
+    }
+
+    // Get git status
+    let gitStatus: string | undefined;
+    try {
+      const { exec } = await import('child_process');
+      const { promisify } = await import('util');
+      const execAsync = promisify(exec);
+      const { stdout } = await execAsync('git status --porcelain', { cwd: workspacePath });
+      if (stdout.trim()) {
+        gitStatus = stdout.trim();
+      }
+    } catch {
+      // Git not available or not a git repo
+    }
+
+    // Get dependencies from package.json
+    let dependencies: Record<string, string> = {};
+    let devDependencies: Record<string, string> = {};
+    let techStack: string[] = [];
+
+    try {
+      const pkgPath = path.join(workspacePath, 'package.json');
+      const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+      const pkg = JSON.parse(pkgContent);
+      dependencies = pkg.dependencies || {};
+      devDependencies = pkg.devDependencies || {};
+
+      // Detect tech stack
+      const allDeps = { ...dependencies, ...devDependencies };
+      if (allDeps['react']) techStack.push('React');
+      if (allDeps['next']) techStack.push('Next.js');
+      if (allDeps['vue']) techStack.push('Vue.js');
+      if (allDeps['express']) techStack.push('Express.js');
+      if (allDeps['typescript']) techStack.push('TypeScript');
+      if (allDeps['tailwindcss']) techStack.push('Tailwind CSS');
+      if (allDeps['firebase']) techStack.push('Firebase');
+      if (allDeps['@google/generative-ai']) techStack.push('Google Gemini');
+      if (allDeps['vite']) techStack.push('Vite');
+    } catch {
+      // No package.json
+    }
+
+    // Get structure from index or scan
+    const structure = index?.structure.map(s => s.path) || [];
+
+    return {
+      name: workspaceName,
+      techStack,
+      dependencies: { ...dependencies, ...devDependencies },
+      structure: structure.slice(0, 50),
+      currentFile,
+      recentFiles: this.recentFiles.map(f => path.relative(workspacePath, f)).slice(0, 5),
+      gitStatus,
+    };
+  }
+
+  /**
+   * Format workspace context for inclusion in prompts
+   */
+  formatContextForPrompt(context: WorkspaceContext): string {
+    const parts: string[] = [];
+
+    parts.push(`## Project: ${context.name}`);
+
+    if (context.techStack.length > 0) {
+      parts.push(`**Tech Stack:** ${context.techStack.join(', ')}`);
+    }
+
+    if (context.currentFile) {
+      parts.push(`\n**Current File:** ${context.currentFile.path} (${context.currentFile.language})`);
+      if (context.currentFile.selection) {
+        parts.push(`\n**Selected Code:**\n\`\`\`${context.currentFile.language}\n${context.currentFile.selection}\n\`\`\``);
+      }
+    }
+
+    if (context.recentFiles.length > 0) {
+      parts.push(`\n**Recent Files:** ${context.recentFiles.join(', ')}`);
+    }
+
+    if (context.gitStatus) {
+      parts.push(`\n**Git Status:** ${context.gitStatus.split('\n').length} file(s) modified`);
+    }
+
+    return parts.join('\n');
+  }
+
+  // ============================================================================
+  // AGENT ACTIONS
+  // ============================================================================
+
+  /**
+   * Execute an agent action
+   */
+  async executeAction(action: AgentAction): Promise<string> {
+    switch (action.type) {
+      case 'read_file':
+        return this.readFile(action.params.path);
+
+      case 'write_file':
+        return this.writeFile(action.params.path, action.params.content);
+
+      case 'execute_command':
+        return this.executeCommand(action.params.command);
+
+      case 'search_files':
+        return this.searchFiles(action.params.query, action.params.filePattern);
+
+      case 'insert_code':
+        return this.insertCode(action.params.code, action.params.position);
+
+      case 'open_file':
+        return this.openFile(action.params.path, action.params.line);
+
+      case 'run_test':
+        return this.runTests(action.params.file);
+
+      case 'install_package':
+        return this.installPackage(action.params.packages, action.params.dev);
+
+      case 'git_status':
+        return this.getGitStatus();
+
+      default:
+        return `Unknown action: ${action.type}`;
+    }
+  }
+
+  private async readFile(filePath: string): Promise<string> {
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || '';
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(workspacePath, filePath);
+
+    try {
+      const content = await fs.readFile(absolutePath, 'utf-8');
+      const lines = content.split('\n');
+      if (lines.length > 100) {
+        return `File: ${filePath} (${lines.length} lines, showing first 100)\n\n${lines.slice(0, 100).join('\n')}\n\n... (truncated)`;
+      }
+      return `File: ${filePath}\n\n${content}`;
+    } catch (error) {
+      return `Error reading file: ${error}`;
+    }
+  }
+
+  private async writeFile(filePath: string, content: string): Promise<string> {
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || '';
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(workspacePath, filePath);
+
+    try {
+      await fs.mkdir(path.dirname(absolutePath), { recursive: true });
+      await fs.writeFile(absolutePath, content, 'utf-8');
+
+      // Open the file
+      const doc = await vscode.workspace.openTextDocument(absolutePath);
+      await vscode.window.showTextDocument(doc);
+
+      return `File written: ${filePath}`;
+    } catch (error) {
+      return `Error writing file: ${error}`;
+    }
+  }
+
+  private async executeCommand(command: string): Promise<string> {
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || '';
+
+    try {
+      const { exec } = await import('child_process');
+      const { promisify } = await import('util');
+      const execAsync = promisify(exec);
+
+      const { stdout, stderr } = await execAsync(command, {
+        cwd: workspacePath,
+        timeout: 30000,
+      });
+
+      return `Command: ${command}\n\nOutput:\n${stdout}${stderr ? `\nErrors:\n${stderr}` : ''}`;
+    } catch (error: any) {
+      return `Command failed: ${command}\n\nError: ${error.message}\n${error.stderr || ''}`;
+    }
+  }
+
+  private async searchFiles(query: string, filePattern?: string): Promise<string> {
+    const files = await vscode.workspace.findFiles(
+      filePattern || '**/*',
+      '**/node_modules/**'
+    );
+
+    const matches: string[] = [];
+    const regex = new RegExp(query, 'gi');
+
+    for (const file of files.slice(0, 50)) {
+      try {
+        const doc = await vscode.workspace.openTextDocument(file);
+        const content = doc.getText();
+        const lines = content.split('\n');
+
+        lines.forEach((line, index) => {
+          if (regex.test(line)) {
+            const relativePath = vscode.workspace.asRelativePath(file);
+            matches.push(`${relativePath}:${index + 1}: ${line.trim()}`);
+          }
+        });
+      } catch {
+        // Skip files that can't be read
+      }
+
+      if (matches.length >= 20) break;
+    }
+
+    return matches.length > 0
+      ? `Found ${matches.length} matches:\n\n${matches.join('\n')}`
+      : 'No matches found';
+  }
+
+  private async insertCode(code: string, position?: 'cursor' | 'end' | 'start'): Promise<string> {
+    const editor = vscode.window.activeTextEditor;
+    if (!editor) {
+      return 'No active editor';
+    }
+
+    await editor.edit((editBuilder) => {
+      if (position === 'start') {
+        editBuilder.insert(new vscode.Position(0, 0), code + '\n');
+      } else if (position === 'end') {
+        const lastLine = editor.document.lineCount - 1;
+        const lastChar = editor.document.lineAt(lastLine).text.length;
+        editBuilder.insert(new vscode.Position(lastLine, lastChar), '\n' + code);
+      } else {
+        // Default: at cursor or replace selection
+        if (editor.selection.isEmpty) {
+          editBuilder.insert(editor.selection.active, code);
+        } else {
+          editBuilder.replace(editor.selection, code);
+        }
+      }
+    });
+
+    return 'Code inserted successfully';
+  }
+
+  private async openFile(filePath: string, line?: number): Promise<string> {
+    const workspacePath = vscode.workspace.workspaceFolders?.[0]?.uri.fsPath || '';
+    const absolutePath = path.isAbsolute(filePath) ? filePath : path.join(workspacePath, filePath);
+
+    try {
+      const doc = await vscode.workspace.openTextDocument(absolutePath);
+      const editor = await vscode.window.showTextDocument(doc);
+
+      if (line !== undefined) {
+        const position = new vscode.Position(line - 1, 0);
+        editor.selection = new vscode.Selection(position, position);
+        editor.revealRange(new vscode.Range(position, position), vscode.TextEditorRevealType.InCenter);
+      }
+
+      return `Opened: ${filePath}`;
+    } catch (error) {
+      return `Error opening file: ${error}`;
+    }
+  }
+
+  private async runTests(file?: string): Promise<string> {
+    const command = file ? `npm test -- ${file}` : 'npm test';
+    return this.executeCommand(command);
+  }
+
+  private async installPackage(packages: string[], dev: boolean = false): Promise<string> {
+    const flag = dev ? '--save-dev' : '';
+    const command = `npm install ${flag} ${packages.join(' ')}`;
+    return this.executeCommand(command);
+  }
+
+  private async getGitStatus(): Promise<string> {
+    return this.executeCommand('git status');
+  }
+
+  // ============================================================================
+  // INTELLIGENT SUGGESTIONS
+  // ============================================================================
+
+  /**
+   * Get smart suggestions based on current context
+   */
+  async getSuggestions(): Promise<string[]> {
+    const suggestions: string[] = [];
+    const context = await this.getWorkspaceContext();
+
+    // Suggest based on current file
+    if (context.currentFile) {
+      const ext = path.extname(context.currentFile.path);
+
+      if (['.ts', '.tsx', '.js', '.jsx'].includes(ext)) {
+        suggestions.push('Explain this code');
+        suggestions.push('Add TypeScript types');
+        suggestions.push('Refactor for better readability');
+        suggestions.push('Add error handling');
+        suggestions.push('Write unit tests for this');
+      }
+
+      if (context.currentFile.selection) {
+        suggestions.push('Explain selected code');
+        suggestions.push('Refactor selected code');
+        suggestions.push('Generate documentation');
+      }
+    }
+
+    // Suggest based on git status
+    if (context.gitStatus) {
+      suggestions.push('Generate commit message');
+      suggestions.push('Review my changes');
+    }
+
+    // Suggest based on tech stack
+    if (context.techStack.includes('React')) {
+      suggestions.push('Create a new React component');
+      suggestions.push('Add React hooks');
+    }
+
+    if (context.techStack.includes('TypeScript')) {
+      suggestions.push('Fix TypeScript errors');
+      suggestions.push('Improve type definitions');
+    }
+
+    return suggestions.slice(0, 5);
+  }
+
+  // ============================================================================
+  // ENHANCED CHAT PROCESSING
+  // ============================================================================
+
+  /**
+   * Process a chat message with full agent capabilities
+   */
+  async processAgentMessage(
+    message: string,
+    history: Array<{ role: string; content: string }>
+  ): Promise<AgentResponse> {
+    // Get workspace context if enabled
+    let contextString = '';
+    if (this.config.autoInjectContext) {
+      const context = await this.getWorkspaceContext();
+      contextString = this.formatContextForPrompt(context);
+    }
+
+    // Build enhanced message with context
+    const enhancedMessage = contextString
+      ? `${contextString}\n\n---\n\n**User Request:**\n${message}`
+      : message;
+
+    try {
+      // Call the API with enhanced message
+      const response = await this.api.chat({
+        message: enhancedMessage,
+        history,
+        context: contextString,
+      });
+
+      // Parse response for actions and code blocks
+      const codeBlocks = this.extractCodeBlocks(response.reply);
+      const actions = this.detectActions(response.reply, codeBlocks);
+      const suggestions = await this.getSuggestions();
+
+      return {
+        message: response.reply,
+        actions,
+        suggestions: this.config.suggestActions ? suggestions : undefined,
+        codeBlocks,
+        workspaceAware: !!contextString,
+      };
+    } catch (error) {
+      return {
+        message: `Error: ${error}`,
+        workspaceAware: false,
+      };
+    }
+  }
+
+  /**
+   * Extract code blocks from response
+   */
+  private extractCodeBlocks(text: string): CodeBlock[] {
+    const blocks: CodeBlock[] = [];
+    const regex = /```(\w*)\n([\s\S]*?)```/g;
+    let match;
+
+    while ((match = regex.exec(text)) !== null) {
+      blocks.push({
+        language: match[1] || 'text',
+        code: match[2].trim(),
+      });
+    }
+
+    return blocks;
+  }
+
+  /**
+   * Detect suggested actions from response
+   */
+  private detectActions(text: string, codeBlocks: CodeBlock[]): AgentAction[] {
+    const actions: AgentAction[] = [];
+
+    // If there are code blocks, suggest insert action
+    if (codeBlocks.length > 0) {
+      actions.push({
+        type: 'insert_code',
+        params: { code: codeBlocks[0].code },
+        description: 'Insert code at cursor',
+      });
+    }
+
+    // Detect file references
+    const fileMatch = text.match(/(?:file|create|write)\s+[`"]?([^\s`"]+\.[a-z]+)[`"]?/i);
+    if (fileMatch) {
+      actions.push({
+        type: 'open_file',
+        params: { path: fileMatch[1] },
+        description: `Open ${fileMatch[1]}`,
+      });
+    }
+
+    // Detect command suggestions
+    const commandMatch = text.match(/(?:run|execute)\s+[`"]([^`"]+)[`"]/i);
+    if (commandMatch) {
+      actions.push({
+        type: 'execute_command',
+        params: { command: commandMatch[1] },
+        description: `Run: ${commandMatch[1]}`,
+      });
+    }
+
+    // Detect npm install suggestions
+    const npmMatch = text.match(/npm install\s+([^\s`]+)/);
+    if (npmMatch) {
+      actions.push({
+        type: 'install_package',
+        params: { packages: [npmMatch[1]] },
+        description: `Install ${npmMatch[1]}`,
+      });
+    }
+
+    return actions;
+  }
+
+  // ============================================================================
+  // PROACTIVE FEATURES
+  // ============================================================================
+
+  /**
+   * Get proactive refinement for selected text
+   */
+  async getProactiveRefinement(): Promise<string | null> {
+    if (!this.config.proactiveRefine) return null;
+
+    const editor = vscode.window.activeTextEditor;
+    if (!editor || editor.selection.isEmpty) return null;
+
+    const selectedText = editor.document.getText(editor.selection);
+
+    // Check if it looks like a prompt (has some length and structure)
+    if (selectedText.length < 10 || selectedText.length > 2000) return null;
+
+    try {
+      const result = await this.api.analyzePrompt({ prompt: selectedText });
+
+      // Only suggest refinement if score is below threshold
+      if (result.overallScore < 70 && result.suggestions.length > 0) {
+        return result.suggestions[0];
+      }
+    } catch {
+      // Ignore analysis errors
+    }
+
+    return null;
+  }
+
+  dispose() {
+    // Cleanup if needed
+  }
+}
+
+export default AgentService;