prjct-cli 0.11.5 → 0.12.1

package/core/agentic/context-filter.js

@@ -1,354 +0,0 @@
-/**
- * Intelligent Context Filtering System
- *
- * Reduces context window usage by 70-90% by loading only
- * relevant files for each specialized agent
- *
- * @version 1.0.0
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const { glob } = require('glob');
-const log = require('../utils/logger');
-
-class ContextFilter {
-  constructor() {
-    // Cache for file analysis
-    this.fileCache = new Map();
-    // NO HARDCODED PATTERNS - Everything is agentic
-    // Claude decides what files are needed based on analysis
-  }
-
-  /**
-   * Main entry point - filters context based on agent and task
-   * IMPROVED: Supports pre-estimated files for lazy loading
-   */
-  async filterForAgent(agent, task, projectPath, fullContext = {}) {
-    const startTime = Date.now();
-
-    // If files were pre-estimated (lazy loading), use them
-    if (fullContext.estimatedFiles && fullContext.estimatedFiles.length > 0) {
-      const filteredFiles = fullContext.estimatedFiles;
-      
-      const metrics = this.calculateMetrics(
-        fullContext.fileCount || filteredFiles.length,
-        filteredFiles.length,
-        startTime
-      );
-
-      return {
-        files: filteredFiles,
-        patterns: { preEstimated: true },
-        metrics,
-        agent: agent.name,
-        filtered: true
-      };
-    }
-
-    // Fallback to traditional filtering if no pre-estimation
-    // Determine what files this agent needs
-    const relevantPatterns = await this.determineRelevantPatterns(
-      agent,
-      task,
-      projectPath
-    );
-
-    // Load only relevant files
-    const filteredFiles = await this.loadRelevantFiles(
-      projectPath,
-      relevantPatterns
-    );
-
-      // Calculate reduction metrics
-      const metrics = this.calculateMetrics(
-        fullContext.fileCount || 1000, // estimate if not provided
-        filteredFiles.length,
-        startTime
-      );
-
-      return {
-        files: filteredFiles,
-        patterns: {
-          detectedTech: relevantPatterns.detectedTech,
-          projectStructure: relevantPatterns.projectStructure,
-          agentic: true // Flag indicating this was agentic, not hardcoded
-        },
-        metrics,
-        agent: agent.name,
-        filtered: true
-      };
-  }
-
-  /**
-   * REMOVED: initializeTechPatterns() and initializeTaskPatterns()
-   * 
-   * These were hardcoded patterns that limited Claude's knowledge.
-   * Now everything is agentic - Claude decides what files are needed
-   * based on the actual project analysis, not predetermined patterns.
-   * 
-   * The ContextEstimator provides file suggestions, and Claude
-   * uses those along with the project analysis to decide what to load.
-   */
-
-  /**
-   * Determine which patterns to use based on agent and task
-   *
-   * 100% AGENTIC: Uses analyzer for I/O, no hardcoded tech detection.
-   * Claude decides what files matter based on actual project analysis.
-   */
-  async determineRelevantPatterns(agent, task, projectPath) {
-    const analyzer = require('../domain/analyzer');
-    analyzer.init(projectPath);
-
-    // Get REAL file extensions from project (not assumed)
-    const realExtensions = await analyzer.getFileExtensions();
-
-    // Get REAL directory structure (not assumed)
-    const projectStructure = await analyzer.listDirectories();
-
-    // Get config files that exist (not hardcoded list)
-    const configFiles = await analyzer.listConfigFiles();
-
-    // Build patterns from ACTUAL project data
-    const patterns = {
-      include: [],
-      exclude: ['node_modules', '.git', 'dist', 'build', 'coverage', '.next', '.nuxt', 'target', 'vendor'],
-      realExtensions, // Actual extensions found in project
-      projectStructure, // Actual directories
-      configFiles // Actual config files
-    };
-
-    return patterns;
-  }
-
-  /**
-   * Detect actual project structure (no assumptions)
-   */
-  async detectProjectStructure(projectPath) {
-    try {
-      const entries = await fs.readdir(projectPath, { withFileTypes: true });
-      const directories = entries
-        .filter(e => e.isDirectory() && !e.name.startsWith('.'))
-        .map(e => e.name);
-      return directories;
-    } catch {
-      return [];
-    }
-  }
-
-  /**
-   * Detect technologies used in the project
-   *
-   * 100% AGENTIC: Uses analyzer for raw data.
-   * No categorization - Claude decides what's relevant.
-   */
-  async detectProjectTechnologies(projectPath) {
-    try {
-      const analyzer = require('../domain/analyzer');
-      analyzer.init(projectPath);
-
-      // Return raw data for Claude to analyze
-      return {
-        extensions: await analyzer.getFileExtensions(),
-        directories: await analyzer.listDirectories(),
-        configFiles: await analyzer.listConfigFiles()
-      };
-    } catch (error) {
-      log.error('Error detecting project data:', error.message);
-      return { extensions: {}, directories: [], configFiles: [] };
-    }
-  }
-
-  /**
-   * REMOVED: detectTaskType() - was hardcoded pattern matching
-   * 
-   * Task type detection is now agentic - Claude analyzes the task
-   * description and project context to determine what files are needed.
-   * No hardcoded keyword matching.
-   */
-
-  /**
-   * REMOVED: getAgentSpecificPatterns() - was hardcoded agent patterns
-   * 
-   * Agent-specific file selection is now agentic - each agent
-   * has instructions in its template that tell Claude what files
-   * are relevant. No hardcoded assumptions about agent types.
-   */
-
-  /**
-   * Load only relevant files based on patterns
-   */
-  async loadRelevantFiles(projectPath, patterns) {
-    const files = [];
-
-    try {
-      // Build glob patterns
-      const globPatterns = this.buildGlobPatterns(patterns);
-
-      // Execute glob searches
-      for (const pattern of globPatterns) {
-        const matches = await glob(pattern, {
-          cwd: projectPath,
-          ignore: patterns.exclude,
-          nodir: true,
-          follow: false
-        });
-
-        // Ensure matches is always an array (glob v10+ returns array, but be defensive)
-        if (Array.isArray(matches)) {
-          files.push(...matches);
-        } else if (matches) {
-          // Convert iterable to array if needed
-          files.push(...Array.from(matches));
-        }
-      }
-
-      // Remove duplicates and sort
-      const uniqueFiles = [...new Set(files)].sort();
-
-      // Limit to reasonable number
-      const maxFiles = 300;
-      if (uniqueFiles.length > maxFiles) {
-        log.debug(`Limiting context to ${maxFiles} files`);
-        return uniqueFiles.slice(0, maxFiles);
-      }
-
-      // Expand context with related files
-      const expandedFiles = await this.expandContext(uniqueFiles);
-
-      return expandedFiles.slice(0, maxFiles);
-
-    } catch (error) {
-      log.error('Error loading files:', error.message);
-      return [];
-    }
-  }
-
-  /**
-   * Build glob patterns from pattern configuration
-   *
-   * 100% AGENTIC: Uses REAL extensions from project, not hardcoded mapping.
-   * No language→extension assumptions.
-   */
-  buildGlobPatterns(patterns) {
-    const globs = [];
-
-    // Use REAL extensions found in project (no hardcoded mapping)
-    if (patterns.realExtensions && Object.keys(patterns.realExtensions).length > 0) {
-      // Get extensions that actually exist in this project
-      const extensions = Object.keys(patterns.realExtensions)
-        .filter(ext => ext.startsWith('.')) // Only valid extensions
-        .slice(0, 20); // Limit to top 20 most common
-
-      if (extensions.length > 0) {
-        globs.push(`**/*{${extensions.join(',')}}`);
-      }
-    }
-
-    // Use REAL project structure (no assumptions)
-    if (patterns.projectStructure && patterns.projectStructure.length > 0) {
-      patterns.projectStructure.forEach(dir => {
-        // Exclude universal noise directories
-        if (!patterns.exclude.includes(dir)) {
-          globs.push(`${dir}/**/*`);
-        }
-      });
-    }
-
-    // Include REAL config files that exist (not hardcoded list)
-    if (patterns.configFiles && patterns.configFiles.length > 0) {
-      patterns.configFiles.forEach(file => {
-        globs.push(file);
-      });
-    }
-
-    // Fallback: if no patterns detected, include all source-like files
-    if (globs.length === 0) {
-      globs.push('**/*');
-    }
-
-    return globs;
-  }
-
-  /**
-   * Calculate metrics for context reduction
-   */
-  calculateMetrics(originalCount, filteredCount, startTime) {
-    const reduction = originalCount > 0
-      ? Math.round(((originalCount - filteredCount) / originalCount) * 100)
-      : 0;
-
-    return {
-      originalFiles: originalCount,
-      filteredFiles: filteredCount,
-      reductionPercent: reduction,
-      processingTime: Date.now() - startTime,
-      effectiveness: reduction > 70 ? 'high' : reduction > 40 ? 'medium' : 'low'
-    };
-  }
-
-  /**
-   * Check if file exists
-   */
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Expand context with related files (tests, styles, etc.)
-   */
-  async expandContext(files) {
-    const expanded = new Set(files);
-
-    for (const file of files) {
-      const ext = path.extname(file);
-      const basename = path.basename(file, ext);
-      const dirname = path.dirname(file);
-
-      // 1. Look for test files
-      const testPatterns = [
-        path.join(dirname, `${basename}.test${ext}`),
-        path.join(dirname, `${basename}.spec${ext}`),
-        path.join(dirname, '__tests__', `${basename}.test${ext}`),
-        path.join(dirname, 'tests', `${basename}.test${ext}`)
-      ];
-
-      // 2. Look for style files (for UI components)
-      const stylePatterns = [
-        path.join(dirname, `${basename}.css`),
-        path.join(dirname, `${basename}.scss`),
-        path.join(dirname, `${basename}.module.css`),
-        path.join(dirname, `${basename}.module.scss`)
-      ];
-
-      // Check if these related files exist
-      const potentialFiles = [...testPatterns, ...stylePatterns];
-      
-      for (const potential of potentialFiles) {
-        if (!expanded.has(potential) && await this.fileExists(potential)) {
-          expanded.add(potential);
-        }
-      }
-    }
-
-    return Array.from(expanded).sort();
-  }
-
-  /**
-   * Get filter statistics
-   */
-  getStatistics() {
-    return {
-      cachedFiles: this.fileCache.size,
-      agentic: true // All filtering is now agentic, no hardcoded patterns
-    };
-  }
-}
-
-module.exports = ContextFilter;