prjct-cli 0.9.2 → 0.10.0

package/core/domain/task-analyzer.js

@@ -0,0 +1,353 @@
+/**
+ * TaskAnalyzer - Deep Semantic Task Analysis
+ * 
+ * Analyzes tasks semantically, not just keywords
+ * Considers project context, history, and relationships
+ * 
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const TechDetector = require('./tech-detector')
+const configManager = require('../infrastructure/config-manager')
+const pathManager = require('../infrastructure/path-manager')
+
+class TaskAnalyzer {
+  constructor(projectPath) {
+    this.projectPath = projectPath
+    this.projectId = null
+    this.techDetector = null
+    this.taskHistory = null
+  }
+
+  /**
+   * Initialize analyzer with project context
+   */
+  async initialize() {
+    this.projectId = await configManager.getProjectId(this.projectPath)
+    this.techDetector = new TechDetector(this.projectPath)
+    await this.loadTaskHistory()
+  }
+
+  /**
+   * Deep semantic analysis of a task
+   * @param {Object} task - Task object {description, type}
+   * @returns {Promise<Object>} Analysis result
+   */
+  async analyzeTask(task) {
+    if (!this.techDetector) {
+      await this.initialize()
+    }
+
+    const description = (task.description || '').toLowerCase()
+    const type = (task.type || '').toLowerCase()
+    const fullText = `${description} ${type}`.trim()
+
+    // Get project technologies
+    const projectTech = await this.techDetector.detectAll()
+
+    // Multi-domain detection
+    const domains = this.detectDomains(fullText, projectTech)
+
+    // Semantic understanding
+    const semantic = this.analyzeSemantics(fullText, projectTech)
+
+    // Historical patterns
+    const historical = await this.analyzeHistory(fullText)
+
+    // Complexity estimation
+    const complexity = this.estimateComplexity(fullText, domains)
+
+    // Combine all signals
+    const primaryDomain = this.selectPrimaryDomain(domains, semantic, historical)
+    const confidence = this.calculateConfidence(domains, semantic, historical)
+
+    return {
+      primaryDomain,
+      domains, // All detected domains
+      confidence,
+      semantic,
+      historical,
+      complexity,
+      projectTechnologies: projectTech,
+      matchedKeywords: domains[primaryDomain]?.keywords || [],
+      reason: this.buildReason(primaryDomain, domains, semantic, historical),
+      alternatives: this.getAlternatives(primaryDomain, domains)
+    }
+  }
+
+  /**
+   * Detect multiple domains from task description
+   */
+  detectDomains(text, projectTech) {
+    const domains = {}
+
+    // Enhanced patterns with project context
+    const patterns = {
+      frontend: [
+        'component', 'ui', 'user interface', 'frontend', 'client',
+        'style', 'css', 'layout', 'responsive', 'design',
+        'page', 'view', 'template', 'render', 'display',
+        'button', 'form', 'input', 'modal', 'dialog',
+        ...(projectTech.frameworks.filter(f => ['react', 'vue', 'angular', 'svelte', 'next', 'nuxt'].includes(f.toLowerCase())).map(f => f.toLowerCase()))
+      ],
+      backend: [
+        'api', 'server', 'endpoint', 'route', 'middleware',
+        'auth', 'authentication', 'authorization', 'jwt', 'session',
+        'backend', 'service', 'controller', 'handler',
+        'database', 'query', 'model', 'schema',
+        ...(projectTech.frameworks.filter(f => ['express', 'fastify', 'django', 'flask', 'rails', 'phoenix'].includes(f.toLowerCase())).map(f => f.toLowerCase()))
+      ],
+      database: [
+        'database', 'db', 'query', 'migration', 'schema', 'model',
+        'sql', 'data', 'table', 'collection', 'index', 'relation',
+        'postgres', 'mysql', 'mongodb', 'redis'
+      ],
+      devops: [
+        'deploy', 'deployment', 'docker', 'kubernetes', 'k8s',
+        'ci/cd', 'pipeline', 'build', 'ship', 'release',
+        'production', 'infrastructure', 'container', 'orchestration'
+      ],
+      qa: [
+        'test', 'testing', 'bug', 'error', 'fix', 'debug', 'issue',
+        'quality', 'coverage', 'unit test', 'integration test',
+        'e2e', 'spec', 'assertion', 'validation'
+      ],
+      architecture: [
+        'design', 'architecture', 'pattern', 'structure',
+        'refactor', 'refactoring', 'organize', 'plan',
+        'feature', 'system', 'module', 'component design'
+      ]
+    }
+
+    // Score each domain
+    for (const [domain, keywords] of Object.entries(patterns)) {
+      const matches = keywords.filter(keyword => text.includes(keyword))
+      if (matches.length > 0) {
+        domains[domain] = {
+          keywords: matches,
+          count: matches.length,
+          score: matches.length + (matches.length > 2 ? 1 : 0) // Bonus for multiple matches
+        }
+      }
+    }
+
+    return domains
+  }
+
+  /**
+   * Semantic analysis - understand intent, not just keywords
+   */
+  analyzeSemantics(text, projectTech) {
+    const semantic = {
+      intent: null,
+      requiresMultipleAgents: false,
+      complexity: 'medium'
+    }
+
+    // Detect intent patterns
+    if (text.match(/\b(create|add|build|implement|make)\b/)) {
+      semantic.intent = 'create'
+    } else if (text.match(/\b(fix|repair|debug|resolve)\b/)) {
+      semantic.intent = 'fix'
+    } else if (text.match(/\b(improve|optimize|enhance|refactor)\b/)) {
+      semantic.intent = 'improve'
+    } else if (text.match(/\b(test|verify|validate)\b/)) {
+      semantic.intent = 'test'
+    }
+
+    // Detect multi-agent requirements
+    if (text.match(/\b(api|endpoint).*\b(test|spec)\b/) || 
+        text.match(/\b(test|spec).*\b(api|endpoint)\b/)) {
+      semantic.requiresMultipleAgents = true
+      semantic.agents = ['backend', 'qa']
+    }
+
+    if (text.match(/\b(component|ui).*\b(test|spec)\b/) ||
+        text.match(/\b(test|spec).*\b(component|ui)\b/)) {
+      semantic.requiresMultipleAgents = true
+      semantic.agents = ['frontend', 'qa']
+    }
+
+    return semantic
+  }
+
+  /**
+   * Analyze historical patterns
+   */
+  async analyzeHistory(text) {
+    if (!this.taskHistory) {
+      return { confidence: 0, patterns: [] }
+    }
+
+    // Find similar tasks in history
+    const similar = this.taskHistory.filter(task => {
+      const similarity = this.calculateTextSimilarity(text, task.description)
+      return similarity > 0.5
+    })
+
+    if (similar.length === 0) {
+      return { confidence: 0, patterns: [] }
+    }
+
+    // Find most common domain for similar tasks
+    const domainCounts = {}
+    similar.forEach(task => {
+      if (task.domain) {
+        domainCounts[task.domain] = (domainCounts[task.domain] || 0) + 1
+      }
+    })
+
+    const mostCommon = Object.entries(domainCounts)
+      .sort((a, b) => b[1] - a[1])[0]
+
+    return {
+      confidence: mostCommon ? mostCommon[1] / similar.length : 0,
+      patterns: similar.map(t => ({ domain: t.domain, description: t.description })),
+      suggestedDomain: mostCommon ? mostCommon[0] : null
+    }
+  }
+
+  /**
+   * Estimate task complexity
+   */
+  estimateComplexity(text, domains) {
+    let complexity = 'medium'
+
+    // Complexity indicators
+    const simpleIndicators = ['add', 'create', 'simple', 'basic']
+    const complexIndicators = ['refactor', 'optimize', 'architecture', 'migration', 'redesign']
+
+    const simpleCount = simpleIndicators.filter(ind => text.includes(ind)).length
+    const complexCount = complexIndicators.filter(ind => text.includes(ind)).length
+
+    if (complexCount > simpleCount) {
+      complexity = 'high'
+    } else if (simpleCount > 0 && complexCount === 0) {
+      complexity = 'low'
+    }
+
+    // Multiple domains = more complex
+    if (Object.keys(domains).length > 1) {
+      complexity = 'high'
+    }
+
+    return complexity
+  }
+
+  /**
+   * Select primary domain from all signals
+   */
+  selectPrimaryDomain(domains, semantic, historical) {
+    // Priority: historical > semantic > keyword matching
+    if (historical.suggestedDomain && historical.confidence > 0.7) {
+      return historical.suggestedDomain
+    }
+
+    if (semantic.agents && semantic.agents.length > 0) {
+      return semantic.agents[0] // Primary agent for multi-agent tasks
+    }
+
+    // Find domain with highest score
+    const sorted = Object.entries(domains)
+      .sort((a, b) => b[1].score - a[1].score)
+
+    return sorted.length > 0 ? sorted[0][0] : 'generalist'
+  }
+
+  /**
+   * Calculate confidence in domain selection
+   */
+  calculateConfidence(domains, semantic, historical) {
+    let confidence = 0.5 // Base confidence
+
+    // Boost from keyword matches
+    const primaryDomain = this.selectPrimaryDomain(domains, semantic, historical)
+    if (domains[primaryDomain]) {
+      confidence += domains[primaryDomain].score * 0.1
+    }
+
+    // Boost from historical patterns
+    if (historical.confidence > 0) {
+      confidence += historical.confidence * 0.3
+    }
+
+    // Boost from semantic understanding
+    if (semantic.intent) {
+      confidence += 0.1
+    }
+
+    return Math.min(confidence, 1.0)
+  }
+
+  /**
+   * Build human-readable reason
+   */
+  buildReason(primaryDomain, domains, semantic, historical) {
+    const parts = []
+
+    if (historical.suggestedDomain && historical.confidence > 0.7) {
+      parts.push(`Historical pattern: similar tasks used ${primaryDomain}`)
+    }
+
+    if (domains[primaryDomain]) {
+      parts.push(`Keywords: ${domains[primaryDomain].keywords.join(', ')}`)
+    }
+
+    if (semantic.intent) {
+      parts.push(`Intent: ${semantic.intent}`)
+    }
+
+    return parts.join(' | ') || `Detected ${primaryDomain} domain`
+  }
+
+  /**
+   * Get alternative domains
+   */
+  getAlternatives(primaryDomain, domains) {
+    return Object.keys(domains)
+      .filter(d => d !== primaryDomain)
+      .sort((a, b) => domains[b].score - domains[a].score)
+  }
+
+  /**
+   * Load task history from memory
+   */
+  async loadTaskHistory() {
+    try {
+      const memoryPath = pathManager.getFilePath(this.projectId, 'memory', 'context.jsonl')
+      const content = await fs.readFile(memoryPath, 'utf-8')
+      const lines = content.split('\n').filter(Boolean)
+
+      this.taskHistory = lines
+        .map(line => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter(entry => entry && entry.type === 'task_start' && entry.domain)
+        .slice(-100) // Last 100 tasks
+    } catch {
+      this.taskHistory = []
+    }
+  }
+
+  /**
+   * Calculate text similarity (simple Jaccard)
+   */
+  calculateTextSimilarity(text1, text2) {
+    const words1 = new Set(text1.toLowerCase().split(/\s+/))
+    const words2 = new Set(text2.toLowerCase().split(/\s+/))
+
+    const intersection = new Set([...words1].filter(w => words2.has(w)))
+    const union = new Set([...words1, ...words2])
+
+    return intersection.size / union.size
+  }
+}
+
+module.exports = TaskAnalyzer
+

package/core/domain/tech-detector.js

@@ -0,0 +1,365 @@
+/**
+ * TechDetector - Dynamic Technology Detection
+ * 
+ * NO HARDCODING - Detects technologies from actual project files
+ * Works with ANY technology stack (Elixir, Phoenix, Svelte, etc.)
+ * 
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+
+class TechDetector {
+  constructor(projectPath) {
+    this.projectPath = projectPath
+    this.cache = null
+  }
+
+  /**
+   * Detect all technologies in the project
+   * Returns structured data about languages, frameworks, tools
+   * @returns {Promise<Object>} - { languages: [], frameworks: [], tools: [], packageManagers: [] }
+   */
+  async detectAll() {
+    if (this.cache) {
+      return this.cache
+    }
+
+    const detected = {
+      languages: [],
+      frameworks: [],
+      tools: [],
+      packageManagers: [],
+      databases: [],
+      buildTools: [],
+      testFrameworks: []
+    }
+
+    // Detect from package managers (most reliable source)
+    await this.detectFromPackageJson(detected)
+    await this.detectFromCargoToml(detected)
+    await this.detectFromGoMod(detected)
+    await this.detectFromRequirements(detected)
+    await this.detectFromGemfile(detected)
+    await this.detectFromMixExs(detected) // Elixir
+    await this.detectFromPomXml(detected) // Maven/Java
+    await this.detectFromComposerJson(detected) // PHP
+
+    // Detect from config files
+    await this.detectFromConfigFiles(detected)
+
+    // Detect from directory structure
+    await this.detectFromStructure(detected)
+
+    // Cache result
+    this.cache = detected
+    return detected
+  }
+
+  /**
+   * Detect from package.json (Node.js/JavaScript/TypeScript)
+   */
+  async detectFromPackageJson(detected) {
+    try {
+      const packagePath = path.join(this.projectPath, 'package.json')
+      const content = await fs.readFile(packagePath, 'utf-8')
+      const pkg = JSON.parse(content)
+
+      detected.packageManagers.push('npm')
+
+      // Language
+      if (pkg.dependencies?.typescript || pkg.devDependencies?.typescript) {
+        detected.languages.push('TypeScript')
+      } else {
+        detected.languages.push('JavaScript')
+      }
+
+      // Collect all dependencies (no hardcoding - just list them)
+      const allDeps = {
+        ...(pkg.dependencies || {}),
+        ...(pkg.devDependencies || {})
+      }
+
+      // Frameworks and tools are in dependencies - let Claude decide what's important
+      // We just collect the names, no assumptions
+      const depNames = Object.keys(allDeps)
+      
+      // Common patterns (but not hardcoded - just helpers)
+      for (const dep of depNames) {
+        // Frontend frameworks
+        if (['react', 'vue', 'angular', 'svelte'].includes(dep.toLowerCase())) {
+          detected.frameworks.push(dep)
+        }
+        // Meta-frameworks
+        else if (['next', 'nuxt', 'sveltekit', 'remix'].includes(dep.toLowerCase())) {
+          detected.frameworks.push(dep)
+        }
+        // Backend frameworks
+        else if (['express', 'fastify', 'koa', 'hapi', 'nest'].includes(dep.toLowerCase())) {
+          detected.frameworks.push(dep)
+        }
+        // Build tools
+        else if (['vite', 'webpack', 'rollup', 'esbuild', 'parcel'].includes(dep.toLowerCase())) {
+          detected.buildTools.push(dep)
+        }
+        // Test frameworks
+        else if (['jest', 'vitest', 'mocha', 'jasmine', 'cypress', 'playwright'].includes(dep.toLowerCase())) {
+          detected.testFrameworks.push(dep)
+        }
+        // Databases
+        else if (['mongoose', 'sequelize', 'prisma', 'typeorm'].includes(dep.toLowerCase())) {
+          detected.databases.push(dep)
+        }
+      }
+
+      // Also check for yarn/pnpm
+      if (await this.fileExists('yarn.lock')) {
+        detected.packageManagers.push('yarn')
+      }
+      if (await this.fileExists('pnpm-lock.yaml')) {
+        detected.packageManagers.push('pnpm')
+      }
+    } catch (error) {
+      // File doesn't exist or invalid JSON - skip
+    }
+  }
+
+  /**
+   * Detect from Cargo.toml (Rust)
+   */
+  async detectFromCargoToml(detected) {
+    try {
+      const cargoPath = path.join(this.projectPath, 'Cargo.toml')
+      await fs.readFile(cargoPath, 'utf-8')
+      
+      detected.languages.push('Rust')
+      detected.packageManagers.push('Cargo')
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from go.mod (Go)
+   */
+  async detectFromGoMod(detected) {
+    try {
+      const goModPath = path.join(this.projectPath, 'go.mod')
+      await fs.readFile(goModPath, 'utf-8')
+      
+      detected.languages.push('Go')
+      detected.packageManagers.push('Go Modules')
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from requirements.txt (Python)
+   */
+  async detectFromRequirements(detected) {
+    try {
+      const reqPath = path.join(this.projectPath, 'requirements.txt')
+      const content = await fs.readFile(reqPath, 'utf-8')
+      
+      detected.languages.push('Python')
+      detected.packageManagers.push('pip')
+      
+      // Detect common frameworks
+      const lines = content.split('\n').map(l => l.trim().toLowerCase())
+      if (lines.some(l => l.includes('django'))) detected.frameworks.push('Django')
+      if (lines.some(l => l.includes('flask'))) detected.frameworks.push('Flask')
+      if (lines.some(l => l.includes('fastapi'))) detected.frameworks.push('FastAPI')
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from Gemfile (Ruby)
+   */
+  async detectFromGemfile(detected) {
+    try {
+      const gemfilePath = path.join(this.projectPath, 'Gemfile')
+      const content = await fs.readFile(gemfilePath, 'utf-8')
+      
+      detected.languages.push('Ruby')
+      detected.packageManagers.push('Bundler')
+      
+      if (content.includes('rails')) {
+        detected.frameworks.push('Rails')
+      }
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from mix.exs (Elixir)
+   */
+  async detectFromMixExs(detected) {
+    try {
+      const mixPath = path.join(this.projectPath, 'mix.exs')
+      const content = await fs.readFile(mixPath, 'utf-8')
+      
+      detected.languages.push('Elixir')
+      detected.packageManagers.push('Mix')
+      
+      if (content.includes('phoenix')) {
+        detected.frameworks.push('Phoenix')
+      }
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from pom.xml (Maven/Java)
+   */
+  async detectFromPomXml(detected) {
+    try {
+      const pomPath = path.join(this.projectPath, 'pom.xml')
+      await fs.readFile(pomPath, 'utf-8')
+      
+      detected.languages.push('Java')
+      detected.packageManagers.push('Maven')
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from composer.json (PHP)
+   */
+  async detectFromComposerJson(detected) {
+    try {
+      const composerPath = path.join(this.projectPath, 'composer.json')
+      const content = await fs.readFile(composerPath, 'utf-8')
+      const composer = JSON.parse(content)
+      
+      detected.languages.push('PHP')
+      detected.packageManagers.push('Composer')
+      
+      const allDeps = {
+        ...(composer.require || {}),
+        ...(composer['require-dev'] || {})
+      }
+      
+      if (Object.keys(allDeps).some(d => d.includes('laravel'))) {
+        detected.frameworks.push('Laravel')
+      }
+      if (Object.keys(allDeps).some(d => d.includes('symfony'))) {
+        detected.frameworks.push('Symfony')
+      }
+    } catch (error) {
+      // File doesn't exist - skip
+    }
+  }
+
+  /**
+   * Detect from config files (Docker, etc.)
+   */
+  async detectFromConfigFiles(detected) {
+    // Docker
+    if (await this.fileExists('Dockerfile')) {
+      detected.tools.push('Docker')
+    }
+    if (await this.fileExists('docker-compose.yml') || await this.fileExists('docker-compose.yaml')) {
+      detected.tools.push('Docker Compose')
+    }
+
+    // Kubernetes
+    if (await this.fileExists('k8s') || await this.fileExists('kubernetes')) {
+      detected.tools.push('Kubernetes')
+    }
+
+    // Terraform
+    if (await this.fileExists('.tf') || await this.findFiles('*.tf')) {
+      detected.tools.push('Terraform')
+    }
+  }
+
+  /**
+   * Detect from directory structure
+   */
+  async detectFromStructure(_detected) {
+    try {
+      const entries = await fs.readdir(this.projectPath, { withFileTypes: true })
+      const dirs = entries.filter(e => e.isDirectory()).map(e => e.name)
+
+      // Common patterns (but not assumptions - just hints)
+      // Could analyze structure here in the future
+      if (dirs.includes('src') && dirs.includes('lib')) {
+        // Could be Elixir, but don't assume
+      }
+    } catch (error) {
+      // Can't read directory - skip
+    }
+  }
+
+  /**
+   * Get a summary string of detected technologies
+   * Useful for agent generation
+   */
+  async getSummary() {
+    const tech = await this.detectAll()
+    const parts = []
+
+    if (tech.languages.length > 0) {
+      parts.push(`Languages: ${tech.languages.join(', ')}`)
+    }
+    if (tech.frameworks.length > 0) {
+      parts.push(`Frameworks: ${tech.frameworks.join(', ')}`)
+    }
+    if (tech.tools.length > 0) {
+      parts.push(`Tools: ${tech.tools.join(', ')}`)
+    }
+    if (tech.databases.length > 0) {
+      parts.push(`Databases: ${tech.databases.join(', ')}`)
+    }
+
+    return parts.join(' | ')
+  }
+
+  /**
+   * Helper: Check if file exists
+   */
+  async fileExists(filename) {
+    try {
+      await fs.access(path.join(this.projectPath, filename))
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Helper: Find files matching pattern
+   */
+  async findFiles(pattern) {
+    try {
+      const { exec } = require('child_process')
+      const { promisify } = require('util')
+      const execAsync = promisify(exec)
+      
+      const { stdout } = await execAsync(
+        `find . -name "${pattern}" -type f ! -path "*/node_modules/*" ! -path "*/.git/*" | head -1`,
+        { cwd: this.projectPath }
+      )
+      return stdout.trim().length > 0
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Clear cache (useful after project changes)
+   */
+  clearCache() {
+    this.cache = null
+  }
+}
+
+module.exports = TechDetector
+