prjct-cli 0.10.6 → 0.10.9

package/core/domain/agent-generator.js

@@ -2,6 +2,7 @@ const fs = require('fs').promises
 const path = require('path')
 const os = require('os')
 const AgentLoader = require('./agent-loader')
+const log = require('../utils/logger')
 
 /**
  * AgentGenerator - Universal Dynamic Agent Generation
@@ -22,7 +23,7 @@ class AgentGenerator {
    * Universal - works with ANY technology stack
    */
   async generateDynamicAgent(agentName, config) {
-    console.log(`   🤖 Generating ${agentName} agent...`)
+    log.debug(`Generating ${agentName} agent...`)
     await fs.mkdir(this.outputDir, { recursive: true })
 
     // Generate concise, actionable agent prompt
@@ -30,11 +31,61 @@ class AgentGenerator {
 
     const outputPath = path.join(this.outputDir, `${agentName}.md`)
     await fs.writeFile(outputPath, content, 'utf-8')
-    console.log(`   ✅ ${agentName} agent created`)
+    log.debug(`${agentName} agent created`)
 
     return { name: agentName }
   }
 
+  /**
+   * Generate agents from tech analysis - 100% AGENTIC
+   * Claude decides what agents are needed based on actual project tech
+   * NO HARDCODED LISTS - reads analysis and decides
+   */
+  async generateAgentsFromTech(context) {
+    const { detectedTech, analysisSummary, projectPath } = context
+    const agents = []
+    
+    // Read agent generation template - Claude will use this to decide
+    const templatePath = path.join(__dirname, '../../templates/agents/AGENTS.md')
+    let agentTemplate = ''
+    try {
+      agentTemplate = await fs.readFile(templatePath, 'utf-8')
+    } catch {
+      // Fallback if template doesn't exist
+      agentTemplate = 'Generate agents based on detected technologies'
+    }
+    
+    // Build context for Claude to decide
+    // Pass full tech info, let Claude categorize and decide what agents are needed
+    const techSummary = {
+      languages: detectedTech.languages || [],
+      frameworks: detectedTech.frameworks || [],
+      buildTools: detectedTech.buildTools || [],
+      testFrameworks: detectedTech.testFrameworks || [],
+      databases: detectedTech.databases || [],
+      tools: detectedTech.tools || [],
+      allDependencies: detectedTech.allDependencies || []
+    }
+    
+    // For now, generate basic agents based on what we detected
+    // But this should be replaced with Claude decision-making
+    // TODO: Make this fully agentic by having Claude read the template and decide
+    
+    // Temporary: Generate agents for detected domains (agentic, not hardcoded)
+    // Claude will eventually decide this based on template
+    if (techSummary.languages.length > 0 || techSummary.frameworks.length > 0) {
+      // Generate a general development agent
+      await this.generateDynamicAgent('developer', {
+        role: 'Development Specialist',
+        domain: 'general',
+        projectContext: techSummary
+      })
+      agents.push('developer')
+    }
+    
+    return agents.map(name => ({ name }))
+  }
+
   /**
    * Build comprehensive agent prompt
    */
@@ -104,11 +155,11 @@ ${config.contextFilter || 'Only relevant files'}
           const filePath = path.join(this.outputDir, file)
           await fs.unlink(filePath)
           removed.push(type)
-          console.log(`   🗑️  ${type.toUpperCase()} agent removed (no longer needed)`)
+          log.debug(`${type} agent removed`)
         }
       }
     } catch (error) {
-      console.error('Error during cleanup:', error.message)
+      log.error('Agent cleanup failed:', error.message)
     }
 
     return removed

package/core/domain/analyzer.js

@@ -81,6 +81,128 @@ class CodebaseAnalyzer {
     }
   }
 
+  /**
+   * Read Gemfile if it exists (Ruby)
+   * @returns {Promise<string|null>}
+   */
+  async readGemfile() {
+    try {
+      const gemfilePath = path.join(this.projectPath, 'Gemfile')
+      return await fs.readFile(gemfilePath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read mix.exs if it exists (Elixir)
+   * @returns {Promise<string|null>}
+   */
+  async readMixExs() {
+    try {
+      const mixPath = path.join(this.projectPath, 'mix.exs')
+      return await fs.readFile(mixPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read pom.xml if it exists (Java/Maven)
+   * @returns {Promise<string|null>}
+   */
+  async readPomXml() {
+    try {
+      const pomPath = path.join(this.projectPath, 'pom.xml')
+      return await fs.readFile(pomPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read composer.json if it exists (PHP)
+   * @returns {Promise<Object|null>}
+   */
+  async readComposerJson() {
+    try {
+      const composerPath = path.join(this.projectPath, 'composer.json')
+      const content = await fs.readFile(composerPath, 'utf-8')
+      return JSON.parse(content)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Read pyproject.toml if it exists (Python)
+   * @returns {Promise<string|null>}
+   */
+  async readPyprojectToml() {
+    try {
+      const pyprojectPath = path.join(this.projectPath, 'pyproject.toml')
+      return await fs.readFile(pyprojectPath, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Get all file extensions in project with counts
+   * I/O PURO - Solo cuenta, no interpreta
+   * @returns {Promise<Object>} - {'.js': 45, '.ts': 23, ...}
+   */
+  async getFileExtensions() {
+    try {
+      const { stdout } = await exec(
+        'find . -type f ! -path "*/node_modules/*" ! -path "*/.git/*" ! -path "*/dist/*" ! -path "*/.next/*" | sed "s/.*\\./\\./" | sort | uniq -c | sort -rn',
+        { cwd: this.projectPath }
+      )
+      const extensions = {}
+      stdout.trim().split('\n').filter(Boolean).forEach(line => {
+        const match = line.trim().match(/^\s*(\d+)\s+(\.\w+)$/)
+        if (match) {
+          extensions[match[2]] = parseInt(match[1])
+        }
+      })
+      return extensions
+    } catch {
+      return {}
+    }
+  }
+
+  /**
+   * List all config files in project root
+   * I/O PURO - Solo lista, no categoriza
+   * @returns {Promise<string[]>}
+   */
+  async listConfigFiles() {
+    try {
+      const entries = await fs.readdir(this.projectPath)
+      const configPatterns = [
+        /^package\.json$/,
+        /^Cargo\.toml$/,
+        /^go\.mod$/,
+        /^requirements\.txt$/,
+        /^Gemfile$/,
+        /^mix\.exs$/,
+        /^pom\.xml$/,
+        /^composer\.json$/,
+        /^pyproject\.toml$/,
+        /^tsconfig.*\.json$/,
+        /^\..*rc(\.json|\.js|\.cjs)?$/,
+        /^Dockerfile$/,
+        /^docker-compose.*\.ya?ml$/,
+        /^\.env.*$/,
+      ]
+      return entries.filter(entry =>
+        configPatterns.some(pattern => pattern.test(entry))
+      )
+    } catch {
+      return []
+    }
+  }
+
   /**
    * List all directories in project root
    * @returns {Promise<string[]>}

package/core/domain/context-estimator.js

@@ -9,6 +9,7 @@
 
 const path = require('path')
 const { glob } = require('glob')
+const log = require('../utils/logger')
 
 class ContextEstimator {
   /**
@@ -50,66 +51,44 @@ class ContextEstimator {
 
   /**
    * Get file patterns for a domain
+   *
+   * 100% AGENTIC: Uses REAL project data, not hardcoded patterns.
+   * No domain-specific assumptions or language→extension mapping.
    */
-  getPatternsForDomain(domain, projectTech) {
+  getPatternsForDomain(domain, projectData) {
     const patterns = {
       include: [],
       extensions: [],
-      exclude: ['node_modules', 'dist', 'build', '.git']
+      exclude: ['node_modules', 'dist', 'build', '.git', '.next', 'target', 'vendor', 'coverage']
     }
 
-    switch (domain) {
-      case 'frontend':
-        patterns.include = ['src', 'components', 'pages', 'views', 'app']
-        patterns.extensions = ['.tsx', '.jsx', '.vue', '.svelte', '.css', '.scss', '.styled.js']
-        
-        // Add framework-specific patterns
-        if (projectTech.frameworks) {
-          if (projectTech.frameworks.some(f => f.toLowerCase().includes('next'))) {
-            patterns.include.push('pages', 'app', 'components')
-          }
-          if (projectTech.frameworks.some(f => f.toLowerCase().includes('react'))) {
-            patterns.extensions.push('.tsx', '.jsx')
-          }
-        }
-        break
-
-      case 'backend':
-        patterns.include = ['src', 'lib', 'api', 'routes', 'controllers', 'services', 'app']
-        patterns.extensions = ['.js', '.ts', '.py', '.rb', '.go', '.rs']
-        
-        // Framework-specific
-        if (projectTech.frameworks) {
-          if (projectTech.frameworks.some(f => f.toLowerCase().includes('express'))) {
-            patterns.include.push('routes', 'middleware', 'controllers')
-          }
-          if (projectTech.frameworks.some(f => f.toLowerCase().includes('django'))) {
-            patterns.include.push('views', 'urls', 'models')
-          }
-        }
-        break
-
-      case 'database':
-        patterns.include = ['migrations', 'models', 'schemas', 'db', 'database']
-        patterns.extensions = ['.sql', '.js', '.ts', '.rb', '.py']
-        break
-
-      case 'qa':
-        patterns.include = ['tests', '__tests__', 'spec', 'test']
-        patterns.extensions = ['.test.js', '.test.ts', '.spec.js', '.spec.ts']
-        break
-
-      case 'devops':
-        patterns.include = ['.github', '.gitlab', 'docker', 'k8s', 'kubernetes', 'terraform']
-        patterns.extensions = ['.yml', '.yaml', '.dockerfile', '.sh', '.tf']
-        break
-
-      default:
-        // General - include common source directories
-        patterns.include = ['src', 'lib', 'app']
-        patterns.extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.rb']
+    // Use REAL extensions from project (if provided in projectData)
+    if (projectData && projectData.extensions) {
+      // projectData.extensions is {'.js': 45, '.ts': 23, ...}
+      patterns.extensions = Object.keys(projectData.extensions)
+        .filter(ext => ext.startsWith('.'))
+        .slice(0, 15); // Top 15 extensions
     }
 
+    // Use REAL directories from project (if provided in projectData)
+    if (projectData && projectData.directories) {
+      patterns.include = projectData.directories.filter(dir =>
+        !patterns.exclude.includes(dir)
+      );
+    }
+
+    // If no real data available, use minimal universal fallback
+    if (patterns.extensions.length === 0) {
+      patterns.extensions = ['*']; // All files
+    }
+
+    if (patterns.include.length === 0) {
+      patterns.include = ['.']; // Root directory
+    }
+
+    // NO domain-specific hardcoding
+    // Claude decides what files matter based on actual analysis
+
     return patterns
   }
 
@@ -157,7 +136,7 @@ class ContextEstimator {
       // Remove duplicates and sort
       return [...new Set(files)].sort()
     } catch (error) {
-      console.error('Error finding files:', error.message)
+      log.error('Error finding files:', error.message)
       return []
     }
   }

package/core/domain/smart-cache.js

@@ -12,6 +12,7 @@ const fs = require('fs').promises
 const path = require('path')
 const os = require('os')
 const crypto = require('crypto')
+const log = require('../utils/logger')
 
 class SmartCache {
   constructor(projectId = null) {
@@ -69,7 +70,7 @@ class SmartCache {
 
     // Persist to disk (async, don't wait)
     this.persistToDisk().catch(err => {
-      console.error('Cache persist error:', err.message)
+      log.error('Cache persist error:', err.message)
     })
   }