promptarchitect 0.6.0

package/src/workspaceIndexer.ts

@@ -0,0 +1,766 @@
+/**
+ * Workspace Indexer
+ * 
+ * Scans and indexes the workspace to provide context for prompt refinement.
+ * Creates a lightweight summary of the codebase structure, key files, and patterns.
+ */
+
+import * as vscode from 'vscode';
+import * as path from 'path';
+
+export interface WorkspaceIndex {
+  timestamp: number;
+  workspaceName: string;
+  workspacePath: string;
+  summary: string;
+  structure: FileStructure[];
+  languages: LanguageStats[];
+  keyFiles: KeyFile[];
+  patterns: string[];
+  totalFiles: number;
+  totalLines: number;
+}
+
+interface FileStructure {
+  path: string;
+  type: 'file' | 'directory';
+  language?: string;
+  lineCount?: number;
+  hasTests?: boolean;
+  hasTypes?: boolean;
+}
+
+interface LanguageStats {
+  language: string;
+  fileCount: number;
+  lineCount: number;
+  percentage: number;
+}
+
+interface KeyFile {
+  path: string;
+  type: 'config' | 'entry' | 'readme' | 'test' | 'types' | 'api' | 'component';
+  summary: string;
+}
+
+// File patterns to identify key files
+const KEY_FILE_PATTERNS: Record<string, RegExp[]> = {
+  config: [
+    /^package\.json$/,
+    /^tsconfig.*\.json$/,
+    /^\.env(\..*)?$/,
+    /^vite\.config\.[jt]s$/,
+    /^webpack\.config\.[jt]s$/,
+    /^next\.config\.[jt]s$/,
+    /^tailwind\.config\.[jt]s$/,
+    /^firebase\.json$/,
+    /^docker-compose\.ya?ml$/,
+    /^Dockerfile$/,
+  ],
+  entry: [
+    /^(index|main|app)\.[jt]sx?$/,
+    /^src\/(index|main|app)\.[jt]sx?$/,
+  ],
+  readme: [/^readme\.md$/i, /^docs\/.*\.md$/i],
+  test: [/\.(test|spec)\.[jt]sx?$/, /__tests__\//],
+  types: [/\.d\.ts$/, /types?\.[jt]s$/],
+  api: [/api\/.*\.[jt]s$/, /routes?\/.*\.[jt]s$/, /controllers?\/.*\.[jt]s$/],
+  component: [/components?\/.*\.[jt]sx?$/, /views?\/.*\.[jt]sx?$/],
+};
+
+// Directories to skip
+const SKIP_DIRECTORIES = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  'out',
+  '.next',
+  '.nuxt',
+  'coverage',
+  '.vscode',
+  '.idea',
+  '__pycache__',
+  'venv',
+  '.env',
+  'vendor',
+  'target',
+  'bin',
+  'obj',
+]);
+
+// File extensions to include
+const INCLUDE_EXTENSIONS = new Set([
+  '.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs',
+  '.py', '.pyw',
+  '.java', '.kt', '.scala',
+  '.go',
+  '.rs',
+  '.c', '.cpp', '.h', '.hpp',
+  '.cs',
+  '.rb',
+  '.php',
+  '.swift',
+  '.vue', '.svelte',
+  '.html', '.css', '.scss', '.less',
+  '.json', '.yaml', '.yml', '.toml',
+  '.md', '.mdx',
+  '.sql',
+  '.sh', '.bash', '.zsh',
+  '.dockerfile',
+]);
+
+// Language mapping
+const EXTENSION_TO_LANGUAGE: Record<string, string> = {
+  '.ts': 'TypeScript',
+  '.tsx': 'TypeScript (React)',
+  '.js': 'JavaScript',
+  '.jsx': 'JavaScript (React)',
+  '.py': 'Python',
+  '.java': 'Java',
+  '.go': 'Go',
+  '.rs': 'Rust',
+  '.c': 'C',
+  '.cpp': 'C++',
+  '.cs': 'C#',
+  '.rb': 'Ruby',
+  '.php': 'PHP',
+  '.swift': 'Swift',
+  '.kt': 'Kotlin',
+  '.vue': 'Vue',
+  '.svelte': 'Svelte',
+  '.html': 'HTML',
+  '.css': 'CSS',
+  '.scss': 'SCSS',
+  '.json': 'JSON',
+  '.yaml': 'YAML',
+  '.yml': 'YAML',
+  '.md': 'Markdown',
+  '.sql': 'SQL',
+  '.sh': 'Shell',
+};
+
+export class WorkspaceIndexer {
+  private context: vscode.ExtensionContext;
+  private statusBarItem: vscode.StatusBarItem;
+  private isIndexing = false;
+
+  constructor(context: vscode.ExtensionContext) {
+    this.context = context;
+    this.statusBarItem = vscode.window.createStatusBarItem(
+      vscode.StatusBarAlignment.Left,
+      50
+    );
+    this.statusBarItem.command = 'promptarchitect.indexWorkspace';
+  }
+
+  /**
+   * Get the current workspace index
+   */
+  getIndex(): WorkspaceIndex | undefined {
+    return this.context.workspaceState.get<WorkspaceIndex>('workspaceIndex');
+  }
+
+  /**
+   * Check if index exists and is recent (less than 1 hour old)
+   */
+  hasValidIndex(): boolean {
+    const index = this.getIndex();
+    if (!index) return false;
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+    return index.timestamp > oneHourAgo;
+  }
+
+  /**
+   * Get a compact context string for prompt refinement
+   */
+  getContextForPrompt(): string {
+    const index = this.getIndex();
+    if (!index) {
+      return '';
+    }
+
+    const parts: string[] = [];
+    
+    parts.push(`## Workspace Context: ${index.workspaceName}`);
+    parts.push('');
+    parts.push(`**Project Summary:** ${index.summary}`);
+    parts.push('');
+    
+    // Languages
+    if (index.languages.length > 0) {
+      parts.push('**Tech Stack:**');
+      const topLanguages = index.languages.slice(0, 5);
+      parts.push(topLanguages.map(l => `- ${l.language} (${l.percentage.toFixed(1)}%)`).join('\n'));
+      parts.push('');
+    }
+
+    // Key files summary
+    if (index.keyFiles.length > 0) {
+      parts.push('**Key Files:**');
+      const keyFilesSummary = index.keyFiles.slice(0, 10).map(f => `- ${f.path}: ${f.summary}`);
+      parts.push(keyFilesSummary.join('\n'));
+      parts.push('');
+    }
+
+    // Project structure (top-level only)
+    const topLevelDirs = index.structure
+      .filter(f => f.type === 'directory' && !f.path.includes('/'))
+      .map(f => f.path);
+    
+    if (topLevelDirs.length > 0) {
+      parts.push('**Project Structure:**');
+      parts.push('```');
+      parts.push(topLevelDirs.map(d => `├── ${d}/`).join('\n'));
+      parts.push('```');
+      parts.push('');
+    }
+
+    // Detected patterns
+    if (index.patterns.length > 0) {
+      parts.push('**Detected Patterns:**');
+      parts.push(index.patterns.map(p => `- ${p}`).join('\n'));
+    }
+
+    return parts.join('\n');
+  }
+
+  /**
+   * Automatically index workspace if not already indexed (no user prompt)
+   * This runs silently in the background for autonomous operation
+   */
+  async ensureIndexed(): Promise<boolean> {
+    // If already indexed and valid, return immediately
+    if (this.hasValidIndex()) {
+      return true;
+    }
+
+    // If not indexed, automatically index without user interaction
+    const index = await this.indexWorkspaceSilent();
+    return index !== undefined;
+  }
+
+  /**
+   * Show prompt to index workspace (legacy method for manual triggering)
+   */
+  async promptToIndex(): Promise<boolean> {
+    const index = this.getIndex();
+    
+    let message: string;
+    let yesButton: string;
+    
+    if (!index) {
+      message = 'Index your workspace for smarter prompt refinement? This scans your project structure to provide better context.';
+      yesButton = 'Index Workspace';
+    } else {
+      const age = Math.round((Date.now() - index.timestamp) / (1000 * 60));
+      message = `Workspace was indexed ${age} minutes ago. Re-index for updated context?`;
+      yesButton = 'Re-index';
+    }
+
+    const choice = await vscode.window.showInformationMessage(
+      message,
+      { modal: false },
+      yesButton,
+      'Not Now'
+    );
+
+    if (choice === yesButton) {
+      await this.indexWorkspace();
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Index the workspace silently (no UI notifications)
+   * Used for autonomous background indexing
+   */
+  async indexWorkspaceSilent(): Promise<WorkspaceIndex | undefined> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      return undefined;
+    }
+
+    if (this.isIndexing) {
+      // Wait for current indexing to complete
+      return new Promise((resolve) => {
+        const checkInterval = setInterval(() => {
+          if (!this.isIndexing) {
+            clearInterval(checkInterval);
+            resolve(this.getIndex());
+          }
+        }, 100);
+      });
+    }
+
+    return this.performIndexing(workspaceFolders[0], false);
+  }
+
+  /**
+   * Index the workspace with progress UI
+   */
+  async indexWorkspace(): Promise<WorkspaceIndex | undefined> {
+    const workspaceFolders = vscode.workspace.workspaceFolders;
+    if (!workspaceFolders || workspaceFolders.length === 0) {
+      vscode.window.showWarningMessage('No workspace folder open');
+      return undefined;
+    }
+
+    if (this.isIndexing) {
+      vscode.window.showInformationMessage('Indexing already in progress...');
+      return undefined;
+    }
+
+    return this.performIndexing(workspaceFolders[0], true);
+  }
+
+  /**
+   * Core indexing logic
+   */
+  private async performIndexing(
+    workspaceFolder: vscode.WorkspaceFolder,
+    showProgress: boolean
+  ): Promise<WorkspaceIndex | undefined> {
+    if (this.isIndexing) {
+      return undefined;
+    }
+
+    this.isIndexing = true;
+    const workspacePath = workspaceFolder.uri.fsPath;
+    const workspaceName = workspaceFolder.name;
+
+    const indexingTask = async (
+      progress?: vscode.Progress<{ message?: string; increment?: number }>,
+      token?: vscode.CancellationToken
+    ): Promise<WorkspaceIndex | undefined> => {
+      try {
+        progress?.report({ message: 'Scanning files...', increment: 0 });
+
+        const structure: FileStructure[] = [];
+        const keyFiles: KeyFile[] = [];
+        const languageMap = new Map<string, { fileCount: number; lineCount: number }>();
+        let totalFiles = 0;
+        let totalLines = 0;
+
+        // Create a dummy token if none provided (for silent mode)
+        const cancellationToken = token || { isCancellationRequested: false } as vscode.CancellationToken;
+        const dummyProgress = { report: () => {} };
+
+        // Scan workspace
+        const files = await this.scanDirectory(
+          workspacePath, 
+          '', 
+          progress || dummyProgress as any, 
+          cancellationToken
+        );
+        
+        if (token?.isCancellationRequested) {
+          this.isIndexing = false;
+          return undefined;
+        }
+
+        progress?.report({ message: 'Analyzing files...', increment: 50 });
+
+        for (const file of files) {
+          if (token?.isCancellationRequested) break;
+
+          const ext = path.extname(file.path).toLowerCase();
+          const language = EXTENSION_TO_LANGUAGE[ext] || 'Other';
+
+          // Update language stats
+          const stats = languageMap.get(language) || { fileCount: 0, lineCount: 0 };
+          stats.fileCount++;
+          stats.lineCount += file.lineCount || 0;
+          languageMap.set(language, stats);
+
+          totalFiles++;
+          totalLines += file.lineCount || 0;
+
+          // Check if it's a key file
+          const keyFileType = this.identifyKeyFile(file.path);
+          if (keyFileType) {
+            keyFiles.push({
+              path: file.path,
+              type: keyFileType,
+              summary: await this.summarizeKeyFile(workspacePath, file.path, keyFileType),
+            });
+          }
+
+          structure.push(file);
+        }
+
+        progress?.report({ message: 'Building index...', increment: 80 });
+
+        // Calculate language percentages
+        const languages: LanguageStats[] = Array.from(languageMap.entries())
+          .map(([language, stats]) => ({
+            language,
+            fileCount: stats.fileCount,
+            lineCount: stats.lineCount,
+            percentage: (stats.lineCount / Math.max(totalLines, 1)) * 100,
+          }))
+          .sort((a, b) => b.lineCount - a.lineCount);
+
+        // Detect patterns
+        const patterns = this.detectPatterns(structure, keyFiles);
+
+        // Generate summary
+        const summary = this.generateSummary(workspaceName, languages, keyFiles, patterns);
+
+        const index: WorkspaceIndex = {
+          timestamp: Date.now(),
+          workspaceName,
+          workspacePath,
+          summary,
+          structure,
+          languages,
+          keyFiles,
+          patterns,
+          totalFiles,
+          totalLines,
+        };
+
+        // Save to workspace state
+        await this.context.workspaceState.update('workspaceIndex', index);
+
+        progress?.report({ message: 'Complete!', increment: 100 });
+
+        this.updateStatusBar(index);
+        
+        if (showProgress) {
+          vscode.window.showInformationMessage(
+            `✅ Workspace indexed: ${totalFiles} files, ${languages.length} languages detected`
+          );
+        }
+
+        this.isIndexing = false;
+        return index;
+      } catch (error) {
+        this.isIndexing = false;
+        if (showProgress) {
+          vscode.window.showErrorMessage(`Indexing failed: ${error}`);
+        }
+        return undefined;
+      }
+    };
+
+    // Run with or without progress UI
+    if (showProgress) {
+      return vscode.window.withProgress(
+        {
+          location: vscode.ProgressLocation.Notification,
+          title: 'Indexing workspace',
+          cancellable: true,
+        },
+        indexingTask
+      );
+    } else {
+      // Silent mode - no progress UI
+      return indexingTask();
+    }
+  }
+
+  /**
+   * Scan a directory recursively
+   */
+  private async scanDirectory(
+    basePath: string,
+    relativePath: string,
+    progress: vscode.Progress<{ message?: string; increment?: number }>,
+    token: vscode.CancellationToken
+  ): Promise<FileStructure[]> {
+    const results: FileStructure[] = [];
+    const fullPath = path.join(basePath, relativePath);
+
+    try {
+      const entries = await vscode.workspace.fs.readDirectory(vscode.Uri.file(fullPath));
+
+      for (const [name, type] of entries) {
+        if (token.isCancellationRequested) break;
+
+        const entryRelativePath = relativePath ? `${relativePath}/${name}` : name;
+
+        if (type === vscode.FileType.Directory) {
+          // Skip ignored directories
+          if (SKIP_DIRECTORIES.has(name)) continue;
+
+          results.push({
+            path: entryRelativePath,
+            type: 'directory',
+          });
+
+          // Recurse into subdirectory (limit depth to 5)
+          const depth = entryRelativePath.split('/').length;
+          if (depth < 5) {
+            const subResults = await this.scanDirectory(basePath, entryRelativePath, progress, token);
+            results.push(...subResults);
+          }
+        } else if (type === vscode.FileType.File) {
+          const ext = path.extname(name).toLowerCase();
+          
+          // Only include relevant file types
+          if (!INCLUDE_EXTENSIONS.has(ext) && !name.startsWith('.')) continue;
+
+          // Get line count (approximate for large files)
+          let lineCount = 0;
+          try {
+            const uri = vscode.Uri.file(path.join(fullPath, name));
+            const stat = await vscode.workspace.fs.stat(uri);
+            
+            // Only read small files for line count
+            if (stat.size < 500000) { // 500KB limit
+              const content = await vscode.workspace.fs.readFile(uri);
+              lineCount = Buffer.from(content).toString('utf-8').split('\n').length;
+            } else {
+              // Estimate for large files
+              lineCount = Math.round(stat.size / 50); // ~50 bytes per line estimate
+            }
+          } catch {
+            // Ignore read errors
+          }
+
+          results.push({
+            path: entryRelativePath,
+            type: 'file',
+            language: EXTENSION_TO_LANGUAGE[ext],
+            lineCount,
+          });
+        }
+      }
+    } catch {
+      // Ignore directory read errors
+    }
+
+    return results;
+  }
+
+  /**
+   * Identify if a file is a key file
+   */
+  private identifyKeyFile(filePath: string): KeyFile['type'] | null {
+    const fileName = path.basename(filePath).toLowerCase();
+    
+    for (const [type, patterns] of Object.entries(KEY_FILE_PATTERNS)) {
+      for (const pattern of patterns) {
+        if (pattern.test(fileName) || pattern.test(filePath)) {
+          return type as KeyFile['type'];
+        }
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Generate a brief summary of a key file
+   */
+  private async summarizeKeyFile(
+    basePath: string,
+    relativePath: string,
+    type: KeyFile['type']
+  ): Promise<string> {
+    const fullPath = path.join(basePath, relativePath);
+    
+    try {
+      const uri = vscode.Uri.file(fullPath);
+      const stat = await vscode.workspace.fs.stat(uri);
+      
+      // Only read small files
+      if (stat.size > 100000) {
+        return `Large ${type} file`;
+      }
+
+      const content = await vscode.workspace.fs.readFile(uri);
+      const text = Buffer.from(content).toString('utf-8');
+
+      switch (type) {
+        case 'config':
+          return this.summarizeConfig(relativePath, text);
+        case 'readme':
+          return this.summarizeReadme(text);
+        case 'entry':
+          return 'Application entry point';
+        case 'test':
+          return 'Test file';
+        case 'types':
+          return 'Type definitions';
+        case 'api':
+          return 'API endpoint/route';
+        case 'component':
+          return 'UI component';
+        default:
+          return type;
+      }
+    } catch {
+      return type;
+    }
+  }
+
+  private summarizeConfig(fileName: string, content: string): string {
+    try {
+      if (fileName.endsWith('package.json')) {
+        const pkg = JSON.parse(content);
+        const deps = Object.keys(pkg.dependencies || {}).length;
+        const devDeps = Object.keys(pkg.devDependencies || {}).length;
+        return `${pkg.name || 'npm package'} - ${deps} deps, ${devDeps} devDeps`;
+      }
+      if (fileName.includes('tsconfig')) {
+        return 'TypeScript configuration';
+      }
+      if (fileName.includes('dockerfile')) {
+        return 'Docker container config';
+      }
+    } catch {
+      // Ignore parse errors
+    }
+    return 'Configuration file';
+  }
+
+  private summarizeReadme(content: string): string {
+    // Get first line that's not empty or a header marker
+    const lines = content.split('\n');
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('!')) {
+        return trimmed.slice(0, 100) + (trimmed.length > 100 ? '...' : '');
+      }
+    }
+    return 'Project documentation';
+  }
+
+  /**
+   * Detect project patterns
+   */
+  private detectPatterns(structure: FileStructure[], keyFiles: KeyFile[]): string[] {
+    const patterns: string[] = [];
+    const dirs = new Set(structure.filter(f => f.type === 'directory').map(f => f.path.split('/')[0]));
+    const files = structure.filter(f => f.type === 'file').map(f => f.path);
+
+    // Framework detection
+    if (files.some(f => f.includes('next.config'))) patterns.push('Next.js framework');
+    if (files.some(f => f.includes('nuxt.config'))) patterns.push('Nuxt.js framework');
+    if (files.some(f => f.includes('vite.config'))) patterns.push('Vite build tool');
+    if (dirs.has('pages') && files.some(f => f.endsWith('.tsx') || f.endsWith('.jsx'))) {
+      patterns.push('Pages-based routing');
+    }
+    if (dirs.has('app') && files.some(f => f.includes('app/') && f.endsWith('page.tsx'))) {
+      patterns.push('App Router (Next.js 13+)');
+    }
+
+    // Structure patterns
+    if (dirs.has('src')) patterns.push('src/ directory structure');
+    if (dirs.has('components')) patterns.push('Component-based architecture');
+    if (dirs.has('api') || dirs.has('routes')) patterns.push('API routes');
+    if (dirs.has('hooks') || files.some(f => f.includes('/use') && f.endsWith('.ts'))) {
+      patterns.push('Custom React hooks');
+    }
+    if (dirs.has('services')) patterns.push('Service layer pattern');
+    if (dirs.has('utils') || dirs.has('helpers')) patterns.push('Utility functions');
+    if (dirs.has('contexts') || dirs.has('context')) patterns.push('React Context API');
+    if (dirs.has('store') || dirs.has('redux') || files.some(f => f.includes('store.'))) {
+      patterns.push('State management');
+    }
+
+    // Testing
+    if (dirs.has('__tests__') || dirs.has('tests') || files.some(f => f.includes('.test.') || f.includes('.spec.'))) {
+      patterns.push('Test suite present');
+    }
+
+    // TypeScript
+    if (files.some(f => f.endsWith('.ts') || f.endsWith('.tsx'))) {
+      patterns.push('TypeScript');
+    }
+
+    // Styling
+    if (files.some(f => f.includes('tailwind'))) patterns.push('Tailwind CSS');
+    if (files.some(f => f.endsWith('.scss'))) patterns.push('SCSS styling');
+    if (files.some(f => f.endsWith('.module.css'))) patterns.push('CSS Modules');
+
+    // Backend
+    if (files.some(f => f.includes('firebase'))) patterns.push('Firebase integration');
+    if (files.some(f => f.includes('prisma'))) patterns.push('Prisma ORM');
+    if (dirs.has('functions')) patterns.push('Serverless functions');
+
+    return patterns;
+  }
+
+  /**
+   * Generate a summary of the workspace
+   */
+  private generateSummary(
+    name: string,
+    languages: LanguageStats[],
+    keyFiles: KeyFile[],
+    patterns: string[]
+  ): string {
+    const parts: string[] = [];
+    
+    // Primary language
+    if (languages.length > 0) {
+      const primary = languages[0];
+      parts.push(`${primary.language} project`);
+    }
+
+    // Framework
+    const framework = patterns.find(p => p.includes('framework') || p.includes('Next.js') || p.includes('Nuxt'));
+    if (framework) {
+      parts.push(`using ${framework.replace(' framework', '')}`);
+    }
+
+    // Key patterns
+    const relevantPatterns = patterns
+      .filter(p => !p.includes('framework'))
+      .slice(0, 3);
+    if (relevantPatterns.length > 0) {
+      parts.push(`with ${relevantPatterns.join(', ')}`);
+    }
+
+    return parts.join(' ') || `${name} workspace`;
+  }
+
+  /**
+   * Update status bar with index info
+   */
+  private updateStatusBar(index: WorkspaceIndex) {
+    const age = Math.round((Date.now() - index.timestamp) / (1000 * 60));
+    this.statusBarItem.text = `$(database) Indexed (${age}m ago)`;
+    this.statusBarItem.tooltip = `Workspace: ${index.workspaceName}\nFiles: ${index.totalFiles}\nLines: ${index.totalLines}\nClick to re-index`;
+    this.statusBarItem.show();
+  }
+
+  /**
+   * Show status bar item
+   */
+  showStatusBar() {
+    const index = this.getIndex();
+    if (index) {
+      this.updateStatusBar(index);
+    } else {
+      this.statusBarItem.text = '$(database) Not indexed';
+      this.statusBarItem.tooltip = 'Click to index workspace for better prompt context';
+      this.statusBarItem.show();
+    }
+  }
+
+  /**
+   * Hide status bar item
+   */
+  hideStatusBar() {
+    this.statusBarItem.hide();
+  }
+
+  /**
+   * Clear the index
+   */
+  async clearIndex() {
+    await this.context.workspaceState.update('workspaceIndex', undefined);
+    this.statusBarItem.text = '$(database) Not indexed';
+    this.statusBarItem.tooltip = 'Click to index workspace';
+  }
+
+  dispose() {
+    this.statusBarItem.dispose();
+  }
+}