prjct-cli 0.10.6 → 0.10.8

package/core/domain/task-analyzer.js

@@ -9,7 +9,7 @@
 
 const fs = require('fs').promises
 const path = require('path')
-const TechDetector = require('./tech-detector')
+const analyzer = require('./analyzer')
 const configManager = require('../infrastructure/config-manager')
 const pathManager = require('../infrastructure/path-manager')
 
@@ -17,7 +17,6 @@ class TaskAnalyzer {
   constructor(projectPath) {
     this.projectPath = projectPath
     this.projectId = null
-    this.techDetector = null
     this.taskHistory = null
   }
 
@@ -26,17 +25,21 @@ class TaskAnalyzer {
    */
   async initialize() {
     this.projectId = await configManager.getProjectId(this.projectPath)
-    this.techDetector = new TechDetector(this.projectPath)
+    analyzer.init(this.projectPath)
     await this.loadTaskHistory()
   }
 
   /**
    * Deep semantic analysis of a task
+   *
+   * 100% AGENTIC: No hardcoded patterns. Uses task description
+   * and historical patterns only. Claude decides domain relevance.
+   *
    * @param {Object} task - Task object {description, type}
    * @returns {Promise<Object>} Analysis result
    */
   async analyzeTask(task) {
-    if (!this.techDetector) {
+    if (!this.projectId) {
       await this.initialize()
     }
 
@@ -44,109 +47,68 @@ class TaskAnalyzer {
     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)
+    // Get raw project data (no categorization)
+    const projectData = {
+      packageJson: await analyzer.readPackageJson(),
+      extensions: await analyzer.getFileExtensions(),
+      directories: await analyzer.listDirectories(),
+      configFiles: await analyzer.listConfigFiles()
+    }
 
-    // Semantic understanding
-    const semantic = this.analyzeSemantics(fullText, projectTech)
+    // Semantic understanding (intent-based, not keyword-based)
+    const semantic = this.analyzeSemantics(fullText)
 
     // Historical patterns
     const historical = await this.analyzeHistory(fullText)
 
     // Complexity estimation
-    const complexity = this.estimateComplexity(fullText, domains)
+    const complexity = this.estimateComplexity(fullText)
 
-    // Combine all signals
-    const primaryDomain = this.selectPrimaryDomain(domains, semantic, historical)
-    const confidence = this.calculateConfidence(domains, semantic, historical)
+    // Primary domain from history and intent (not hardcoded patterns)
+    const primaryDomain = this.selectPrimaryDomain(semantic, historical)
+    const confidence = this.calculateConfidence(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)
+      projectData, // Raw data for Claude to analyze
+      matchedKeywords: [], // No keyword matching - Claude decides
+      reason: this.buildReason(primaryDomain, semantic, historical),
+      alternatives: ['full-stack', 'generalist']
     }
   }
 
   /**
-   * Detect multiple domains from task description
+   * Domain detection removed - 100% AGENTIC
+   *
+   * NO hardcoded keyword lists or framework categorization.
+   * Claude analyzes the task description and project context
+   * to determine the appropriate domain.
+   *
+   * This method is kept for backward compatibility but returns empty.
+   * Use analyzeTask() which provides raw data for Claude.
    */
-  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
+  detectDomains(text) {
+    // No hardcoded patterns - Claude decides domain
+    return {}
   }
 
   /**
-   * Semantic analysis - understand intent, not just keywords
+   * Semantic analysis - understand intent
+   *
+   * Only detects basic intent (create, fix, improve, test).
+   * Claude handles detailed domain analysis.
    */
-  analyzeSemantics(text, projectTech) {
+  analyzeSemantics(text) {
     const semantic = {
       intent: null,
-      requiresMultipleAgents: false,
-      complexity: 'medium'
+      requiresMultipleAgents: false
     }
 
-    // Detect intent patterns
+    // Detect basic intent patterns (these are universal, not tech-specific)
     if (text.match(/\b(create|add|build|implement|make)\b/)) {
       semantic.intent = 'create'
     } else if (text.match(/\b(fix|repair|debug|resolve)\b/)) {
@@ -157,18 +119,8 @@ class TaskAnalyzer {
       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']
-    }
+    // No hardcoded multi-agent detection
+    // Claude decides if multiple agents are needed based on context
 
     return semantic
   }
@@ -210,71 +162,61 @@ class TaskAnalyzer {
   }
 
   /**
-   * Estimate task complexity
+   * Estimate task complexity based on intent words
    */
-  estimateComplexity(text, domains) {
-    let complexity = 'medium'
-
-    // Complexity indicators
-    const simpleIndicators = ['add', 'create', 'simple', 'basic']
-    const complexIndicators = ['refactor', 'optimize', 'architecture', 'migration', 'redesign']
+  estimateComplexity(text) {
+    // Simple complexity indicators (universal, not tech-specific)
+    const simpleIndicators = ['add', 'create', 'simple', 'basic', 'small']
+    const complexIndicators = ['refactor', 'optimize', 'architecture', 'migration', 'redesign', 'overhaul']
 
     const simpleCount = simpleIndicators.filter(ind => text.includes(ind)).length
     const complexCount = complexIndicators.filter(ind => text.includes(ind)).length
 
     if (complexCount > simpleCount) {
-      complexity = 'high'
+      return 'high'
     } else if (simpleCount > 0 && complexCount === 0) {
-      complexity = 'low'
+      return 'low'
     }
 
-    // Multiple domains = more complex
-    if (Object.keys(domains).length > 1) {
-      complexity = 'high'
-    }
-
-    return complexity
+    return 'medium'
   }
 
   /**
-   * Select primary domain from all signals
+   * Select primary domain from history and semantics
+   *
+   * 100% AGENTIC: No keyword matching. Uses only:
+   * - Historical patterns from past tasks
+   * - Basic intent detection
+   * Claude decides actual domain based on project context.
    */
-  selectPrimaryDomain(domains, semantic, historical) {
-    // Priority: historical > semantic > keyword matching
-    if (historical.suggestedDomain && historical.confidence > 0.7) {
+  selectPrimaryDomain(semantic, historical) {
+    // Priority: historical > default
+    if (historical && 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
+    // Map intent to suggested domain (loose mapping, Claude refines)
+    if (semantic && semantic.intent === 'test') {
+      return 'qa'
     }
 
-    // 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'
+    // Default: generalist (Claude decides based on context)
+    return 'generalist'
   }
 
   /**
-   * Calculate confidence in domain selection
+   * Calculate confidence based on available signals
    */
-  calculateConfidence(domains, semantic, historical) {
+  calculateConfidence(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) {
+    if (historical && historical.confidence > 0) {
       confidence += historical.confidence * 0.3
     }
 
     // Boost from semantic understanding
-    if (semantic.intent) {
+    if (semantic && semantic.intent) {
       confidence += 0.1
     }
 
@@ -284,31 +226,18 @@ class TaskAnalyzer {
   /**
    * Build human-readable reason
    */
-  buildReason(primaryDomain, domains, semantic, historical) {
+  buildReason(primaryDomain, semantic, historical) {
     const parts = []
 
-    if (historical.suggestedDomain && historical.confidence > 0.7) {
-      parts.push(`Historical pattern: similar tasks used ${primaryDomain}`)
+    if (historical && historical.suggestedDomain && historical.confidence > 0.7) {
+      parts.push(`Historical: similar tasks used ${primaryDomain}`)
     }
 
-    if (domains[primaryDomain]) {
-      parts.push(`Keywords: ${domains[primaryDomain].keywords.join(', ')}`)
-    }
-
-    if (semantic.intent) {
+    if (semantic && 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)
+    return parts.join(' | ') || 'Claude will analyze task in context'
   }
 
   /**

package/core/domain/task-stack.js

@@ -5,6 +5,7 @@
 
 const path = require('path');
 const fs = require('fs').promises;
+const log = require('../utils/logger');
 
 class TaskStack {
   constructor(projectPath) {
@@ -168,7 +169,7 @@ class TaskStack {
       try {
         entries.push(JSON.parse(line));
       } catch (error) {
-        console.error('Error parsing stack line:', error);
+        log.error('Error parsing stack line:', error.message);
       }
     }
 

package/core/utils/logger.js

@@ -0,0 +1,64 @@
+/**
+ * Logger - Centralized logging with levels
+ *
+ * Silent by default. Enable with:
+ *   PRJCT_DEBUG=1       (all logs)
+ *   PRJCT_DEBUG=error   (errors only)
+ *   PRJCT_DEBUG=warn    (errors + warnings)
+ *   PRJCT_DEBUG=info    (errors + warnings + info)
+ *   PRJCT_DEBUG=debug   (everything)
+ *
+ * Usage:
+ *   const log = require('./utils/logger')
+ *   log.debug('Processing files...')
+ *   log.info('Task started')
+ *   log.warn('Cache miss')
+ *   log.error('Failed to load', error.message)
+ */
+
+const LEVELS = { error: 0, warn: 1, info: 2, debug: 3 }
+
+const debugEnv = process.env.PRJCT_DEBUG || process.env.DEBUG || ''
+const isEnabled = debugEnv === '1' || debugEnv === 'true' || debugEnv.includes('prjct')
+
+// Determine log level
+let currentLevel = -1 // disabled by default
+if (isEnabled) {
+  if (debugEnv === '1' || debugEnv === 'true' || debugEnv === 'prjct') {
+    currentLevel = LEVELS.debug // all logs
+  } else if (LEVELS[debugEnv] !== undefined) {
+    currentLevel = LEVELS[debugEnv]
+  } else {
+    currentLevel = LEVELS.debug
+  }
+}
+
+// No-op function for disabled logs
+const noop = () => {}
+
+// Create logger methods
+const logger = {
+  error: currentLevel >= LEVELS.error
+    ? (...args) => console.error('[prjct:error]', ...args)
+    : noop,
+
+  warn: currentLevel >= LEVELS.warn
+    ? (...args) => console.warn('[prjct:warn]', ...args)
+    : noop,
+
+  info: currentLevel >= LEVELS.info
+    ? (...args) => console.log('[prjct:info]', ...args)
+    : noop,
+
+  debug: currentLevel >= LEVELS.debug
+    ? (...args) => console.log('[prjct:debug]', ...args)
+    : noop,
+
+  // Check if logging is enabled (useful for expensive log prep)
+  isEnabled: () => currentLevel >= 0,
+
+  // Get current level name
+  level: () => Object.keys(LEVELS).find(k => LEVELS[k] === currentLevel) || 'disabled'
+}
+
+module.exports = logger

package/core/utils/output.js

@@ -0,0 +1,54 @@
+/**
+ * Minimal Output System for prjct-cli
+ * Spinner while working → Single line result
+ */
+
+const chalk = require('chalk')
+
+const FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+const SPEED = 80
+
+let interval = null
+let frame = 0
+
+const truncate = (s, max = 50) => (s && s.length > max ? s.slice(0, max - 1) + '…' : s || '')
+const clear = () => process.stdout.write('\r' + ' '.repeat(70) + '\r')
+
+const out = {
+  spin(msg) {
+    this.stop()
+    interval = setInterval(() => {
+      process.stdout.write(`\r${chalk.cyan(FRAMES[frame++ % 10])} ${truncate(msg, 55)}`)
+    }, SPEED)
+    return this
+  },
+
+  done(msg) {
+    this.stop()
+    console.log(`${chalk.green('✓')} ${truncate(msg, 65)}`)
+    return this
+  },
+
+  fail(msg) {
+    this.stop()
+    console.log(`${chalk.red('✗')} ${truncate(msg, 65)}`)
+    return this
+  },
+
+  warn(msg) {
+    this.stop()
+    console.log(`${chalk.yellow('⚠')} ${truncate(msg, 65)}`)
+    return this
+  },
+
+  stop() {
+    if (interval) {
+      clearInterval(interval)
+      interval = null
+      clear()
+    }
+    return this
+  }
+}
+
+module.exports = out

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {

package/templates/agentic/agent-routing.md

@@ -0,0 +1,78 @@
+---
+allowed-tools: [Read]
+description: 'Determine which agent should handle a task - Claude decides'
+---
+
+# Agent Routing Instructions
+
+## Objective
+
+Determine the best agent for a task by analyzing the ACTUAL task and project context.
+
+## Step 1: Understand the Task
+
+Read the task description and identify:
+
+- What files will be modified?
+- What type of work is involved?
+- What knowledge is required?
+
+## Step 2: Read Project Context
+
+If project analysis exists, read it to understand:
+
+- What technologies are actually used
+- How the project is structured
+- What patterns are established
+
+## Step 3: Match Task to Agent
+
+Based on your analysis, determine which agent is best suited:
+
+**DO NOT assume:**
+- "React" = frontend agent
+- "Express" = backend agent
+- "Database" = database agent
+
+**DO analyze:**
+- What the task actually requires
+- What files will be touched
+- What expertise is needed
+
+## Available Agent Types
+
+Consider these agent specializations:
+
+- **Coordinator**: High-level planning, task breakdown
+- **Frontend/UX**: UI components, user experience, styling
+- **Backend**: API endpoints, server logic, business rules
+- **Database**: Schema design, queries, migrations
+- **DevOps/QA**: Testing, CI/CD, deployment, infrastructure
+- **Full-stack**: Cross-cutting concerns, multiple layers
+
+## Decision Process
+
+1. Read task description
+2. Identify primary area of work
+3. Consider secondary areas
+4. Choose agent with best expertise match
+
+## Output
+
+Return the recommended agent with reasoning:
+
+```json
+{
+  "agent": "recommended-agent-type",
+  "reasoning": "why this agent is best for the task",
+  "confidence": "high|medium|low",
+  "alternatives": ["other agents that could help"]
+}
+```
+
+## Rules
+
+- **Task-driven, not tech-driven** - Focus on what needs to be done
+- **Context matters** - Same tech can mean different things in different projects
+- **Be flexible** - One project's "backend" might be another's "full-stack"
+- **Explain your reasoning** - Don't just pick, justify

package/templates/agentic/context-filtering.md

@@ -0,0 +1,77 @@
+---
+allowed-tools: [Glob, Read]
+description: 'Filter relevant context for a task - Claude decides what matters'
+---
+
+# Context Filtering Instructions
+
+## Objective
+
+Determine which files and directories are relevant for a given task.
+
+## Step 1: Get Real File Extensions
+
+Instead of assuming extensions, get the ACTUAL extensions in the project:
+
+```bash
+# Get real extensions (analyzer.getFileExtensions())
+```
+
+Use only extensions that EXIST in this project.
+
+## Step 2: Identify Relevant Directories
+
+Based on the task, identify which directories matter:
+
+**DO NOT use hardcoded lists like:**
+- "components" for frontend
+- "routes" for backend
+
+**DO analyze:**
+- Where does this project put similar code?
+- What directory structure does it use?
+- What naming conventions are followed?
+
+## Step 3: Filter by Task Requirements
+
+For the specific task:
+
+1. What type of files will be modified?
+2. What related files might need updates?
+3. What config files are relevant?
+
+## Step 4: Exclude Non-Relevant
+
+Always exclude:
+- `node_modules/`, `vendor/`, etc. (dependencies)
+- `.git/` (version control)
+- `dist/`, `build/`, `target/` (build outputs)
+- Generated files
+
+## Output
+
+Return filtering patterns:
+
+```json
+{
+  "include": {
+    "extensions": [".actual", ".extensions", ".found"],
+    "directories": ["actual/", "directories/", "in/project/"],
+    "files": ["specific-files-if-known"]
+  },
+  "exclude": {
+    "directories": ["node_modules/", ".git/", "dist/"],
+    "patterns": ["*.min.js", "*.map"]
+  },
+  "priority": ["most-relevant-paths-first"],
+  "reasoning": "why these patterns were chosen"
+}
+```
+
+## Rules
+
+- **Use REAL extensions** - Only include extensions that exist in the project
+- **No assumptions** - Don't assume directory names
+- **Task-specific** - Different tasks need different context
+- **Efficient** - Don't include everything, focus on what matters
+- **Explain choices** - Document why certain patterns were included/excluded