prjct-cli 0.9.1 → 0.10.0

package/core/agentic/command-executor.js

@@ -10,11 +10,13 @@ const promptBuilder = require('./prompt-builder')
 const toolRegistry = require('./tool-registry')
 const MandatoryAgentRouter = require('./agent-router')
 const ContextFilter = require('./context-filter')
+const ContextEstimator = require('../domain/context-estimator')
 
 class CommandExecutor {
   constructor() {
     this.agentRouter = new MandatoryAgentRouter()
     this.contextFilter = new ContextFilter()
+    this.contextEstimator = null
   }
 
   /**
@@ -25,45 +27,74 @@ class CommandExecutor {
       // 1. Load template
       const template = await templateLoader.load(commandName)
 
-      // 2. Build FULL context (before filtering)
-      const fullContext = await contextBuilder.build(projectPath, params)
+      // 2. Build METADATA context only (lazy loading - no file reads yet)
+      const metadataContext = await contextBuilder.build(projectPath, params)
 
-      // 3. Check if command requires agent
-      const requiresAgent = template.metadata?.['required-agent'] ||
-                           this.isTaskCommand(commandName)
+      // 3. CRITICAL: Force agent assignment for ALL task-related commands
+      const requiresAgent = template.metadata?.['required-agent'] !== false &&
+                           (template.metadata?.['required-agent'] === true ||
+                            this.isTaskCommand(commandName) ||
+                            this.shouldUseAgent(commandName))
 
-      let context = fullContext
+      let context = metadataContext
       let assignedAgent = null
 
+      // MANDATORY: Assign specialized agent for task commands
       if (requiresAgent) {
-        // 4. MANDATORY: Assign specialized agent
+        // 4. Create task object for analysis
         const task = {
           description: params.task || params.description || commandName,
           type: commandName
         }
 
+        // 5. LAZY CONTEXT: Analyze task FIRST, then estimate files needed
+        // This avoids reading all files before knowing what we need
         const agentAssignment = await this.agentRouter.executeTask(
           task,
-          fullContext,
+          metadataContext, // Only metadata, no files yet
           projectPath
         )
 
         assignedAgent = agentAssignment.agent
+        const taskAnalysis = agentAssignment.taskAnalysis
+
+        // Validate agent was assigned
+        if (!assignedAgent || !assignedAgent.name) {
+          throw new Error(
+            `CRITICAL: Failed to assign agent for command "${commandName}". ` +
+            `System requires ALL task commands to use specialized agents.`
+          )
+        }
+
+        // 6. PRE-FILTER: Estimate which files are needed BEFORE reading
+        if (!this.contextEstimator) {
+          this.contextEstimator = new ContextEstimator()
+        }
+
+        const estimatedFiles = await this.contextEstimator.estimateFiles(
+          taskAnalysis,
+          projectPath
+        )
 
-        // 5. Filter context for this specific agent (70-90% reduction)
+        // 7. Build context ONLY with estimated files (lazy loading)
         const filtered = await this.contextFilter.filterForAgent(
           assignedAgent,
           task,
           projectPath,
-          fullContext
+          {
+            ...metadataContext,
+            estimatedFiles, // Pre-filtered file list
+            fileCount: estimatedFiles.length
+          }
         )
 
         context = {
           ...filtered,
           agent: assignedAgent,
-          originalSize: fullContext.files?.length || 0,
+          originalSize: estimatedFiles.length, // Estimated, not actual full size
           filteredSize: filtered.files?.length || 0,
-          reduction: filtered.metrics?.reductionPercent || 0
+          reduction: filtered.metrics?.reductionPercent || 0,
+          lazyLoaded: true // Flag indicating lazy loading was used
         }
       }
 
@@ -100,10 +131,27 @@ class CommandExecutor {
    * Check if command is task-related
    */
   isTaskCommand(commandName) {
-    const taskCommands = ['work', 'now', 'build', 'feature', 'bug', 'done']
+    const taskCommands = [
+      'work', 'now', 'build', 'feature', 'bug', 'done',
+      'task', 'design', 'cleanup', 'fix', 'test'
+    ]
     return taskCommands.includes(commandName)
   }
 
+  /**
+   * Determine if command should use an agent
+   * Expanded list of commands that benefit from agent specialization
+   */
+  shouldUseAgent(commandName) {
+    // Commands that should ALWAYS use agents
+    const agentCommands = [
+      'work', 'now', 'build', 'feature', 'bug', 'done',
+      'task', 'design', 'cleanup', 'fix', 'test',
+      'sync', 'analyze' // These analyze/modify code, need specialization
+    ]
+    return agentCommands.includes(commandName)
+  }
+
   /**
    * Execute tool with permission check
    * @param {string} toolName - Tool name

package/core/agentic/context-filter.js

@@ -9,9 +9,7 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const glob = require('glob');
-const { promisify } = require('util');
-const globAsync = promisify(glob);
+const { glob } = require('glob');
 
 class ContextFilter {
   constructor() {
@@ -27,10 +25,31 @@ class ContextFilter {
 
   /**
    * 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,
@@ -270,93 +289,29 @@ class ContextFilter {
 
   /**
    * Detect technologies used in the project
+   * NOW USES TechDetector - NO HARDCODING
    */
   async detectProjectTechnologies(projectPath) {
-    const detected = new Set();
-
     try {
-      // Check package.json for JS/TS projects
-      const packageJsonPath = path.join(projectPath, 'package.json');
-      if (await this.fileExists(packageJsonPath)) {
-        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf8'));
-
-        // Check dependencies
-        const deps = {
-          ...packageJson.dependencies,
-          ...packageJson.devDependencies
-        };
-
-        // Detect frameworks
-        if (deps.react) detected.add('react');
-        if (deps.vue) detected.add('vue');
-        if (deps['@angular/core']) detected.add('angular');
-        if (deps.express) detected.add('express');
-        if (deps.next) detected.add('nextjs');
-        if (deps.fastify) detected.add('fastify');
-
-        // Language
-        if (deps.typescript) detected.add('typescript');
-        else detected.add('javascript');
-      }
-
-      // Check Gemfile for Ruby projects
-      const gemfilePath = path.join(projectPath, 'Gemfile');
-      if (await this.fileExists(gemfilePath)) {
-        detected.add('ruby');
-        const gemfile = await fs.readFile(gemfilePath, 'utf8');
-        if (gemfile.includes('rails')) detected.add('rails');
-      }
-
-      // Check requirements.txt or setup.py for Python
-      const requirementsPath = path.join(projectPath, 'requirements.txt');
-      const setupPyPath = path.join(projectPath, 'setup.py');
-      if (await this.fileExists(requirementsPath) || await this.fileExists(setupPyPath)) {
-        detected.add('python');
-
-        if (await this.fileExists(requirementsPath)) {
-          const requirements = await fs.readFile(requirementsPath, 'utf8');
-          if (requirements.includes('django')) detected.add('django');
-          if (requirements.includes('fastapi')) detected.add('fastapi');
-          if (requirements.includes('flask')) detected.add('flask');
-        }
-      }
-
-      // Check go.mod for Go projects
-      const goModPath = path.join(projectPath, 'go.mod');
-      if (await this.fileExists(goModPath)) {
-        detected.add('go');
-      }
-
-      // Check Cargo.toml for Rust
-      const cargoPath = path.join(projectPath, 'Cargo.toml');
-      if (await this.fileExists(cargoPath)) {
-        detected.add('rust');
-      }
-
-      // Check mix.exs for Elixir
-      const mixPath = path.join(projectPath, 'mix.exs');
-      if (await this.fileExists(mixPath)) {
-        detected.add('elixir');
-      }
-
-      // Check for Java/Maven/Gradle
-      const pomPath = path.join(projectPath, 'pom.xml');
-      const gradlePath = path.join(projectPath, 'build.gradle');
-      if (await this.fileExists(pomPath) || await this.fileExists(gradlePath)) {
-        detected.add('java');
-      }
-
-      // Check composer.json for PHP
-      const composerPath = path.join(projectPath, 'composer.json');
-      if (await this.fileExists(composerPath)) {
-        detected.add('php');
-      }
-
+      const TechDetector = require('../domain/tech-detector');
+      const detector = new TechDetector(projectPath);
+      const tech = await detector.detectAll();
+
+      // Convert to array of all detected technologies
+      const all = [
+        ...tech.languages,
+        ...tech.frameworks,
+        ...tech.tools,
+        ...tech.databases,
+        ...tech.buildTools,
+        ...tech.testFrameworks
+      ];
+
+      return Array.from(new Set(all)); // Remove duplicates
     } catch (error) {
       console.error('Error detecting technologies:', error.message);
+      return [];
     }
-
-    return Array.from(detected);
   }
 
   /**
@@ -445,27 +400,36 @@ class ContextFilter {
 
       // Execute glob searches
       for (const pattern of globPatterns) {
-        const matches = await globAsync(pattern, {
+        const matches = await glob(pattern, {
           cwd: projectPath,
           ignore: patterns.exclude,
           nodir: true,
           follow: false
         });
 
-        files.push(...matches);
+        // 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 = 100;
+      const maxFiles = 300;
       if (uniqueFiles.length > maxFiles) {
         console.log(`Limiting context to ${maxFiles} most relevant files`);
         return uniqueFiles.slice(0, maxFiles);
       }
 
-      return uniqueFiles;
+      // Expand context with related files
+      const expandedFiles = await this.expandContext(uniqueFiles);
+
+      return expandedFiles.slice(0, maxFiles);
 
     } catch (error) {
       console.error('Error loading files:', error.message);
@@ -530,6 +494,46 @@ class ContextFilter {
     }
   }
 
+  /**
+   * 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
    */

package/core/agentic/prompt-builder.js

@@ -7,13 +7,45 @@
 class PromptBuilder {
   /**
    * Build concise prompt - only essentials
+   * CRITICAL: Includes full agent content if agent is provided
    */
   build(template, context, state, agent = null) {
     const parts = []
 
     // Agent assignment (if applicable)
+    // CRITICAL: Include full agent content, not just name
     if (agent) {
-      parts.push(`AGENT: ${agent.name}\n`)
+      parts.push(`# AGENT ASSIGNMENT\n`)
+      parts.push(`Agent: ${agent.name}\n`)
+      
+      // Include role if available
+      if (agent.role) {
+        parts.push(`Role: ${agent.role}\n`)
+      }
+      
+      // Include domain if available
+      if (agent.domain) {
+        parts.push(`Domain: ${agent.domain}\n`)
+      }
+      
+      // Include skills if available
+      if (agent.skills && agent.skills.length > 0) {
+        parts.push(`Skills: ${agent.skills.join(', ')}\n`)
+      }
+      
+      parts.push(`\n## AGENT INSTRUCTIONS\n`)
+      
+      // CRITICAL: Include full agent content
+      // This is the specialized knowledge for this project
+      if (agent.content) {
+        parts.push(agent.content)
+        parts.push(`\n`)
+      } else if (agent.name) {
+        // Fallback if content not loaded
+        parts.push(`You are the ${agent.name} agent for this project.\n`)
+        parts.push(`Apply your specialized expertise to complete the task.\n\n`)
+      }
+      
       parts.push(`CONTEXT: ${context.filteredSize || 'all'} files (${context.reduction || 0}% reduced)\n\n`)
     }
 
@@ -49,6 +81,9 @@ class PromptBuilder {
       parts.push('\n')
     }
 
+    // Enforcement (Strict Mode)
+    parts.push(this.buildEnforcement());
+
     // Simple execution directive
     parts.push('\nEXECUTE: Follow flow. Use tools. Decide.\n')
 
@@ -91,6 +126,21 @@ class PromptBuilder {
 
     return parts.join('')
   }
+
+  /**
+   * Build enforcement section
+   * Forces Claude to follow the process strictly
+   */
+  buildEnforcement() {
+    return `
+## PROCESS ENFORCEMENT
+1. FOLLOW the Flow strictly. Do not skip steps.
+2. USE the allowed tools only.
+3. IF you are stuck, use the "Ask" tool or stop.
+4. DO NOT hallucinate files or commands.
+5. ALWAYS verify your changes.
+`;
+  }
 }
 
 module.exports = new PromptBuilder()

package/core/commands.js

@@ -1133,7 +1133,6 @@ class PrjctCommands {
    */
   async _cleanupMemory(projectPath) {
     const projectId = await configManager.getProjectId(projectPath)
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
 
     console.log('📊 Analyzing disk usage...\n')
 
@@ -2474,7 +2473,7 @@ Agent: ${agent}
       const AgentGenerator = require('./domain/agent-generator')
       const generator = new AgentGenerator(projectId)
 
-      const generatedAgents = await this._generateAgentsFromAnalysis(summaryContent, generator)
+      const generatedAgents = await this._generateAgentsFromAnalysis(summaryContent, generator, projectPath)
 
       // Step 4: Log to memory
       await this.logToMemory(projectPath, 'agents_generated', {
@@ -2506,91 +2505,118 @@ Agent: ${agent}
 
   /**
    * Generate agents dynamically from analysis summary
-   * Claude decides based on what technologies are detected
+   * 100% DYNAMIC - Uses TechDetector, NO HARDCODING
+   * Claude decides based on actual detected technologies
    * @private
    */
-  async _generateAgentsFromAnalysis(summaryContent, generator) {
+  async _generateAgentsFromAnalysis(summaryContent, generator, projectPath) {
     const agents = []
+    const TechDetector = require('./domain/tech-detector')
+    const detector = new TechDetector(projectPath)
+    const tech = await detector.detectAll()
 
-    // Parse summary to identify technologies
-    // Simple detection based on sections (NOT predetermined patterns)
+    // Generate agents based on ACTUAL detected technologies
+    // No assumptions, no hardcoding - just what we found
 
-    // Detect languages/frameworks from summary
-    const hasJavaScript =
-      summaryContent.includes('JavaScript') || summaryContent.includes('TypeScript')
-    const hasNextJS = summaryContent.includes('Next.js')
-    const hasVite = summaryContent.includes('Vite')
-    const hasReact = summaryContent.includes('react')
-    const hasRust = summaryContent.includes('Rust')
-    const hasGo = summaryContent.includes('Go')
-    const hasPython = summaryContent.includes('Python')
-    const hasDocker = summaryContent.includes('Docker')
-
-    // Generate agents based on detected stack
-    // Each agent is specific to THIS project's stack
+    // Frontend agents - if we have frontend frameworks
+    const frontendFrameworks = tech.frameworks.filter(f => 
+      ['react', 'vue', 'angular', 'svelte', 'next', 'nuxt', 'sveltekit', 'remix'].includes(f.toLowerCase())
+    )
+    const frontendBuildTools = tech.buildTools.filter(t => 
+      ['vite', 'webpack', 'rollup', 'esbuild'].includes(t.toLowerCase())
+    )
 
-    if (hasJavaScript || hasNextJS || hasVite) {
+    if (frontendFrameworks.length > 0 || frontendBuildTools.length > 0 || tech.languages.includes('JavaScript') || tech.languages.includes('TypeScript')) {
+      const frameworkList = frontendFrameworks.length > 0 
+        ? frontendFrameworks.join(', ')
+        : (frontendBuildTools.length > 0 ? frontendBuildTools.join(', ') : 'JavaScript/TypeScript')
+      
       await generator.generateDynamicAgent('frontend-specialist', {
         role: 'Frontend Development Specialist',
-        expertise: `${hasNextJS ? 'Next.js' : hasVite ? 'Vite' : 'JavaScript/TypeScript'}, ${hasReact ? 'React' : 'Modern JavaScript frameworks'}`,
-        responsibilities:
-          'Handle UI components, state management, routing, and frontend architecture',
+        expertise: `${frameworkList}, ${tech.languages.filter(l => ['JavaScript', 'TypeScript'].includes(l)).join(' or ') || 'Modern JavaScript'}`,
+        responsibilities: 'Handle UI components, state management, routing, and frontend architecture',
         projectContext: {
-          detectedFramework: hasNextJS ? 'Next.js' : hasVite ? 'Vite + React' : 'JavaScript',
+          detectedFrameworks: frontendFrameworks,
+          buildTools: frontendBuildTools,
+          languages: tech.languages.filter(l => ['JavaScript', 'TypeScript'].includes(l))
         },
       })
       agents.push('frontend-specialist')
     }
 
-    if (hasRust) {
-      await generator.generateDynamicAgent('rust-developer', {
-        role: 'Rust Development Specialist',
-        expertise: 'Rust, Cargo, performance optimization, memory safety',
-        responsibilities:
-          'Handle Rust codebase, performance-critical components, systems programming',
-        projectContext: { language: 'Rust' },
-      })
-      agents.push('rust-developer')
-    }
+    // Backend agents - if we have backend frameworks or languages
+    const backendFrameworks = tech.frameworks.filter(f => 
+      ['express', 'fastify', 'koa', 'hapi', 'nest', 'django', 'flask', 'fastapi', 'rails', 'phoenix', 'laravel'].includes(f.toLowerCase())
+    )
+    const backendLanguages = tech.languages.filter(l => 
+      ['Go', 'Rust', 'Python', 'Ruby', 'Elixir', 'Java', 'PHP'].includes(l)
+    )
 
-    if (hasGo) {
-      await generator.generateDynamicAgent('go-developer', {
-        role: 'Go Development Specialist',
-        expertise: 'Go, Go modules, concurrency, backend services',
-        responsibilities: 'Handle Go codebase, backend services, API development',
-        projectContext: { language: 'Go' },
+    if (backendFrameworks.length > 0 || backendLanguages.length > 0) {
+      const agentName = backendLanguages.length > 0 
+        ? `${backendLanguages[0].toLowerCase()}-developer`
+        : 'backend-specialist'
+      
+      const expertise = backendFrameworks.length > 0
+        ? backendFrameworks.join(', ')
+        : backendLanguages.join(', ')
+
+      await generator.generateDynamicAgent(agentName, {
+        role: `${backendLanguages[0] || 'Backend'} Development Specialist`,
+        expertise,
+        responsibilities: 'Handle backend services, API development, server logic',
+        projectContext: {
+          detectedFrameworks: backendFrameworks,
+          languages: backendLanguages
+        },
       })
-      agents.push('go-developer')
+      agents.push(agentName)
     }
 
-    if (hasPython) {
-      await generator.generateDynamicAgent('python-developer', {
-        role: 'Python Development Specialist',
-        expertise: 'Python, pip, Django/Flask, data processing',
-        responsibilities: 'Handle Python codebase, backend logic, data processing',
-        projectContext: { language: 'Python' },
+    // Database specialist - if we have database tools
+    if (tech.databases.length > 0) {
+      await generator.generateDynamicAgent('database-specialist', {
+        role: 'Database Specialist',
+        expertise: tech.databases.join(', '),
+        responsibilities: 'Handle database design, queries, migrations, data modeling',
+        projectContext: {
+          databases: tech.databases
+        },
       })
-      agents.push('python-developer')
+      agents.push('database-specialist')
     }
 
-    if (hasDocker) {
+    // DevOps specialist - if we have DevOps tools
+    if (tech.tools.some(t => ['Docker', 'Kubernetes', 'Terraform'].includes(t))) {
       await generator.generateDynamicAgent('devops-specialist', {
         role: 'DevOps & Infrastructure Specialist',
-        expertise: 'Docker, Docker Compose, containerization, deployment',
+        expertise: tech.tools.filter(t => ['Docker', 'Kubernetes', 'Terraform'].includes(t)).join(', '),
         responsibilities: 'Handle containerization, deployment, infrastructure setup',
-        projectContext: { hasDocker: true },
+        projectContext: {
+          tools: tech.tools
+        },
       })
       agents.push('devops-specialist')
     }
 
-    // Always generate a QA specialist if we have code
-    await generator.generateDynamicAgent('qa-specialist', {
-      role: 'Quality Assurance Specialist',
-      expertise: 'Testing frameworks, test automation, quality metrics',
-      responsibilities: 'Handle testing strategy, test creation, quality assurance',
-      projectContext: { role: 'QA' },
-    })
-    agents.push('qa-specialist')
+    // QA specialist - always generate if we have test frameworks or any code
+    if (tech.testFrameworks.length > 0 || tech.languages.length > 0) {
+      const testExpertise = tech.testFrameworks.length > 0
+        ? tech.testFrameworks.join(', ')
+        : 'Testing frameworks, test automation'
+
+      await generator.generateDynamicAgent('qa-specialist', {
+        role: 'Quality Assurance Specialist',
+        expertise: testExpertise,
+        responsibilities: 'Handle testing strategy, test creation, quality assurance',
+        projectContext: {
+          testFrameworks: tech.testFrameworks,
+          languages: tech.languages,
+          role: 'QA'
+        },
+      })
+      agents.push('qa-specialist')
+    }
 
     return agents
   }