prjct-cli 0.10.10 → 0.10.12

package/core/commands.js

@@ -22,6 +22,7 @@ const commandExecutor = require('./agentic/command-executor')
 const contextBuilder = require('./agentic/context-builder')
 const toolRegistry = require('./agentic/tool-registry')
 const memorySystem = require('./agentic/memory-system')
+const AgentRouter = require('./agentic/agent-router')
 const pathManager = require('./infrastructure/path-manager')
 const configManager = require('./infrastructure/config-manager')
 const authorDetector = require('./infrastructure/author-detector')
@@ -46,6 +47,7 @@ class PrjctCommands {
     this.updateChecker = new UpdateChecker()
     this.updateNotificationShown = false
     this.commandExecutor = commandExecutor
+    this.agentRouter = new AgentRouter()
   }
 
   /**
@@ -138,17 +140,24 @@ class PrjctCommands {
       const context = await contextBuilder.build(projectPath, { task })
 
       if (task) {
-        // Set task
-        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\n`
+        // MANDATORY: Assign agent before setting task
+        const agentResult = await this._assignAgentForTask(task, projectPath, context)
+        const agent = agentResult.agent?.name || 'generalist'
+        const confidence = agentResult.routing?.confidence || 0.5
+
+        // Set task WITH agent
+        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\nAgent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`
         await toolRegistry.get('Write')(context.paths.now, nowContent)
 
-        out.done(`${task} (started)`)
+        out.done(`${task} [${agent}]`)
 
         await this.logToMemory(projectPath, 'task_started', {
           task,
+          agent,
+          confidence,
           timestamp: dateHelper.getTimestamp(),
         })
-        return { success: true, task }
+        return { success: true, task, agent }
       } else {
         // Show current task
         const nowContent = await toolRegistry.get('Read')(context.paths.now)
@@ -158,10 +167,12 @@ class PrjctCommands {
           return { success: true, message: 'No active task' }
         }
 
-        // Extract task name for minimal output
+        // Extract task name and agent for minimal output
         const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const agentMatch = nowContent.match(/Agent: ([^\s(]+)/)
         const currentTask = taskMatch ? taskMatch[1] : 'unknown'
-        out.done(`working on: ${currentTask}`)
+        const currentAgent = agentMatch ? agentMatch[1] : ''
+        out.done(`working on: ${currentTask}${currentAgent ? ` [${currentAgent}]` : ''}`)
         return { success: true, content: nowContent }
       }
     } catch (error) {
@@ -427,26 +438,42 @@ class PrjctCommands {
       // Task breakdown
       const tasks = this._breakdownFeatureTasks(description)
 
-      // Write to next.md
+      // MANDATORY: Assign agent to each task
+      const tasksWithAgents = []
+      for (const taskDesc of tasks) {
+        const agentResult = await this._assignAgentForTask(taskDesc, projectPath, context)
+        const agent = agentResult.agent?.name || 'generalist'
+        tasksWithAgents.push({ task: taskDesc, agent })
+      }
+
+      // Write to next.md with agents
       const nextContent =
         (await toolRegistry.get('Read')(context.paths.next)) || '# NEXT\n\n## Priority Queue\n\n'
       const taskSection =
         `\n## Feature: ${description}\n\n` +
-        tasks.map((t, i) => `${i + 1}. [ ] ${t}`).join('\n') +
+        tasksWithAgents.map((t, i) => `${i + 1}. [${t.agent}] [ ] ${t.task}`).join('\n') +
         `\n\nEstimated: ${tasks.length * 2}h\n`
 
       await toolRegistry.get('Write')(context.paths.next, nextContent + taskSection)
 
-      // Log to memory
+      // Log to memory with agent assignments
       await this.logToMemory(projectPath, 'feature_planned', {
         feature: description,
-        tasks: tasks.length,
+        tasks: tasksWithAgents.length,
+        assignments: tasksWithAgents.map(t => ({ task: t.task, agent: t.agent })),
         timestamp: dateHelper.getTimestamp(),
       })
 
-      out.done(`${tasks.length} tasks created`)
+      // Show summary with agent distribution
+      const agentCounts = tasksWithAgents.reduce((acc, t) => {
+        acc[t.agent] = (acc[t.agent] || 0) + 1
+        return acc
+      }, {})
+      const agentSummary = Object.entries(agentCounts).map(([a, c]) => `${a}:${c}`).join(' ')
+
+      out.done(`${tasks.length} tasks [${agentSummary}]`)
 
-      return { success: true, feature: description, tasks }
+      return { success: true, feature: description, tasks: tasksWithAgents }
     } catch (error) {
       out.fail(error.message)
       return { success: false, error: error.message }
@@ -459,36 +486,13 @@ class PrjctCommands {
    * @private
    */
   _breakdownFeatureTasks(description) {
-    // Simplified breakdown - Claude would analyze and create appropriate tasks
-    const lowerDesc = description.toLowerCase()
-
-    if (lowerDesc.includes('test')) {
-      return [
-        'Setup testing framework configuration',
-        'Write tests for core utilities',
-        'Write tests for components/modules',
-        'Add CI/CD test runner',
-        'Update docs with testing guide',
-      ]
-    }
-
-    if (lowerDesc.includes('auth') || lowerDesc.includes('login')) {
-      return [
-        'Design authentication flow',
-        'Implement backend authentication API',
-        'Implement frontend login/signup UI',
-        'Add session management',
-        'Test authentication flow',
-      ]
-    }
-
-    // Default breakdown
+    // AGENTIC: Claude analyzes and creates tasks via templates/analysis/task-breakdown.md
+    // This returns a placeholder - real breakdown happens in template execution
     return [
-      `Research and design ${description}`,
+      `Analyze and plan: ${description}`,
       'Implement core functionality',
-      'Add tests and validation',
-      'Update documentation',
-      'Review and refine',
+      'Test and validate',
+      'Document changes',
     ]
   }
 
@@ -511,10 +515,14 @@ class PrjctCommands {
       const context = await contextBuilder.build(projectPath, { description })
       const severity = this._detectBugSeverity(description)
 
-      // Add to next.md with priority
+      // MANDATORY: Assign agent to bug
+      const agentResult = await this._assignAgentForTask(`fix bug: ${description}`, projectPath, context)
+      const agent = agentResult.agent?.name || 'generalist'
+
+      // Add to next.md with priority and agent
       const nextContent =
         (await toolRegistry.get('Read')(context.paths.next)) || '# NEXT\n\n## Priority Queue\n\n'
-      const bugEntry = `\n## 🐛 BUG [${severity.toUpperCase()}]: ${description}\n\nReported: ${new Date().toLocaleString()}\nPriority: ${severity === 'critical' ? '⚠️ URGENT' : severity === 'high' ? '🔴 High' : '🟡 Normal'}\n`
+      const bugEntry = `\n## 🐛 BUG [${severity.toUpperCase()}] [${agent}]: ${description}\n\nReported: ${new Date().toLocaleString()}\nPriority: ${severity === 'critical' ? '⚠️ URGENT' : severity === 'high' ? '🔴 High' : '🟡 Normal'}\nAssigned: ${agent}\n`
 
       // Insert at top if critical/high, at bottom otherwise
       const updatedContent =
@@ -524,16 +532,17 @@ class PrjctCommands {
 
       await toolRegistry.get('Write')(context.paths.next, updatedContent)
 
-      // Log to memory
+      // Log to memory with agent
       await this.logToMemory(projectPath, 'bug_reported', {
         bug: description,
         severity,
+        agent,
         timestamp: dateHelper.getTimestamp(),
       })
 
-      out.done(`bug [${severity}] tracked`)
+      out.done(`bug [${severity}] → ${agent}`)
 
-      return { success: true, bug: description, severity }
+      return { success: true, bug: description, severity, agent }
     } catch (error) {
       out.fail(error.message)
       return { success: false, error: error.message }
@@ -546,20 +555,8 @@ class PrjctCommands {
    * @private
    */
   _detectBugSeverity(description) {
-    const lowerDesc = description.toLowerCase()
-
-    if (
-      lowerDesc.includes('crash') ||
-      lowerDesc.includes('broken') ||
-      lowerDesc.includes('not working')
-    ) {
-      return 'critical'
-    }
-
-    if (lowerDesc.includes('error') || lowerDesc.includes('fail') || lowerDesc.includes('bug')) {
-      return 'high'
-    }
-
+    // AGENTIC: Claude assesses severity via templates/analysis/bug-severity.md
+    // Returns default - real assessment happens in template execution
     return 'medium'
   }
 
@@ -971,68 +968,8 @@ class PrjctCommands {
    * @private
    */
   _generateArchitectureDesign(target, projectPath) {
-    const projectName = path.basename(projectPath)
-    return `# Architecture Design: ${target}
-
-**Project**: ${projectName}
-**Created**: ${new Date().toLocaleString()}
-**Type**: System Architecture
-
-## Overview
-
-High-level architecture design for ${target}.
-
-## Components
-
-### Core Components
-1. **Component A**
-   - Responsibility: [Define responsibility]
-   - Dependencies: [List dependencies]
-   - Interfaces: [Define interfaces]
-
-2. **Component B**
-   - Responsibility: [Define responsibility]
-   - Dependencies: [List dependencies]
-   - Interfaces: [Define interfaces]
-
-## Data Flow
-
-\`\`\`
-[User] → [Frontend] → [API Gateway] → [Backend Services] → [Database]
-                                    ↓
-                              [Cache Layer]
-\`\`\`
-
-## Technology Stack
-
-- **Frontend**: [Framework/Library]
-- **Backend**: [Framework/Runtime]
-- **Database**: [Type/System]
-- **Deployment**: [Platform/Method]
-
-## Design Decisions
-
-### Decision 1: [Title]
-- **Context**: [Why this decision is needed]
-- **Options**: [Alternatives considered]
-- **Choice**: [What was chosen]
-- **Rationale**: [Why this choice]
-
-## Implementation Plan
-
-1. [ ] Setup project structure
-2. [ ] Implement core components
-3. [ ] Add integration layer
-4. [ ] Testing and validation
-5. [ ] Documentation
-
-## Notes
-
-[Additional notes, constraints, assumptions]
-
----
-*This is a living document. Update as design evolves.*
-`
+    // AGENTIC: Claude generates via templates/design/architecture.md
+    return `# Architecture Design: ${target}\n\n*Use templates/design/architecture.md for full design*\n`
   }
 
   /**
@@ -1040,79 +977,8 @@ High-level architecture design for ${target}.
    * @private
    */
   _generateApiDesign(target) {
-    return `# API Design: ${target}
-
-**Created**: ${new Date().toLocaleString()}
-**Type**: API Specification
-
-## Endpoints
-
-### GET /api/${target.toLowerCase()}
-**Description**: Retrieve ${target}
-
-**Request**:
-\`\`\`
-GET /api/${target.toLowerCase()}?limit=10&offset=0
-\`\`\`
-
-**Response** (200 OK):
-\`\`\`json
-{
-  "data": [],
-  "meta": {
-    "total": 0,
-    "limit": 10,
-    "offset": 0
-  }
-}
-\`\`\`
-
-### POST /api/${target.toLowerCase()}
-**Description**: Create new ${target}
-
-**Request**:
-\`\`\`json
-{
-  "name": "string",
-  "description": "string"
-}
-\`\`\`
-
-**Response** (201 Created):
-\`\`\`json
-{
-  "id": "string",
-  "name": "string",
-  "description": "string",
-  "createdAt": "ISO8601"
-}
-\`\`\`
-
-## Error Handling
-
-\`\`\`json
-{
-  "error": {
-    "code": "ERROR_CODE",
-    "message": "Human-readable message",
-    "details": {}
-  }
-}
-\`\`\`
-
-## Authentication
-
-- **Method**: Bearer Token
-- **Header**: \`Authorization: Bearer <token>\`
-
-## Rate Limiting
-
-- **Limit**: 100 requests/minute
-- **Headers**: \`X-RateLimit-Limit\`, \`X-RateLimit-Remaining\`
-
----
-*Update this specification as API evolves.*
-`
+    // AGENTIC: Claude generates via templates/design/api.md
+    return `# API Design: ${target}\n\n*Use templates/design/api.md for full design*\n`
   }
 
   /**
@@ -1120,79 +986,8 @@ GET /api/${target.toLowerCase()}?limit=10&offset=0
    * @private
    */
   _generateComponentDesign(target) {
-    return `# Component Design: ${target}
-
-**Created**: ${new Date().toLocaleString()}
-**Type**: Component Specification
-
-## Overview
-
-Component for ${target} functionality.
-
-## Props/Interface
-
-\`\`\`typescript
-interface ${target}Props {
-  // Define props
-  id?: string
-  className?: string
-  onAction?: (data: any) => void
-}
-\`\`\`
-
-## State
-
-\`\`\`typescript
-interface ${target}State {
-  // Define internal state
-  loading: boolean
-  data: any[]
-  error: Error | null
-}
-\`\`\`
-
-## Component Structure
-
-\`\`\`
-${target}/
-├── index.ts          # Barrel export
-├── ${target}.tsx     # Main component
-├── ${target}.test.tsx # Tests
-├── ${target}.styles.ts # Styles
-└── types.ts          # Type definitions
-\`\`\`
-
-## Usage Example
-
-\`\`\`tsx
-import { ${target} } from '@/components/${target}'
-
-function App() {
-  return (
-    <${target}
-      id="example"
-      onAction={(data) => console.log(data)}
-    />
-  )
-}
-\`\`\`
-
-## Dependencies
-
-- React
-- [Other libraries]
-
-## Implementation Notes
-
-1. [ ] Setup component structure
-2. [ ] Implement core logic
-3. [ ] Add styling
-4. [ ] Write tests
-5. [ ] Document usage
-
----
-*Component design is iterative. Update as needed.*
-`
+    // AGENTIC: Claude generates via templates/design/component.md
+    return `# Component Design: ${target}\n\n*Use templates/design/component.md for full design*\n`
   }
 
   /**
@@ -1200,68 +995,8 @@ function App() {
    * @private
    */
   _generateDatabaseDesign(target) {
-    return `# Database Design: ${target}
-
-**Created**: ${new Date().toLocaleString()}
-**Type**: Database Schema
-
-## Schema
-
-### Table: ${target.toLowerCase()}
-
-\`\`\`sql
-CREATE TABLE ${target.toLowerCase()} (
-  id SERIAL PRIMARY KEY,
-  name VARCHAR(255) NOT NULL,
-  description TEXT,
-  status VARCHAR(50) DEFAULT 'active',
-  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-  updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-\`\`\`
-
-## Indexes
-
-\`\`\`sql
-CREATE INDEX idx_${target.toLowerCase()}_status ON ${target.toLowerCase()}(status);
-CREATE INDEX idx_${target.toLowerCase()}_created_at ON ${target.toLowerCase()}(created_at);
-\`\`\`
-
-## Relationships
-
-- **Related Tables**: [List related tables]
-- **Foreign Keys**: [Define foreign keys]
-
-## Queries
-
-### Common Queries
-
-\`\`\`sql
--- Get active records
-SELECT * FROM ${target.toLowerCase()} WHERE status = 'active';
-
--- Get recent records
-SELECT * FROM ${target.toLowerCase()}
-ORDER BY created_at DESC
-LIMIT 10;
-\`\`\`
-
-## Migrations
-
-1. [ ] Create initial schema
-2. [ ] Add indexes
-3. [ ] Setup relationships
-4. [ ] Add constraints
-
-## Notes
-
-- Consider partitioning for large datasets
-- Add audit logging if needed
-- Implement soft deletes
-
----
-*Database design should evolve with requirements.*
-`
+    // AGENTIC: Claude generates via templates/design/database.md
+    return `# Database Design: ${target}\n\n*Use templates/design/database.md for full design*\n`
   }
 
   /**
@@ -1269,63 +1004,8 @@ LIMIT 10;
    * @private
    */
   _generateFlowDesign(target) {
-    return `# Flow Design: ${target}
-
-**Created**: ${new Date().toLocaleString()}
-**Type**: Process Flow
-
-## Flow Overview
-
-Process flow for ${target}.
-
-## Steps
-
-\`\`\`
-1. [User Action/Trigger]
-   ↓
-2. [Validation]
-   ↓
-3. [Processing]
-   ↓
-4. [Side Effects]
-   ↓
-5. [Response/Completion]
-\`\`\`
-
-## Detailed Flow
-
-### Step 1: Initial Action
-- **Input**: [What triggers this]
-- **Validation**: [What gets checked]
-- **Output**: [What proceeds]
-
-### Step 2: Processing
-- **Actions**: [What happens]
-- **Dependencies**: [What's needed]
-- **Side Effects**: [What changes]
-
-### Step 3: Completion
-- **Success**: [What happens on success]
-- **Failure**: [What happens on failure]
-- **Notifications**: [Who gets notified]
-
-## Error Handling
-
-- **Error Type 1**: [Recovery strategy]
-- **Error Type 2**: [Recovery strategy]
-
-## Rollback Strategy
-
-[How to undo if needed]
-
-## Monitoring
-
-- **Metrics**: [What to track]
-- **Alerts**: [When to alert]
-
----
-*Document edge cases and special scenarios.*
-`
+    // AGENTIC: Claude generates via templates/design/flow.md
+    return `# Flow Design: ${target}\n\n*Use templates/design/flow.md for full design*\n`
   }
 
   /**
@@ -1661,30 +1341,13 @@ Status: ⏸️  Planned
    * @private
    */
   _calculateHealth(stats) {
-    let score = 50 // Base score
-
-    // Active task is good
-    if (stats.activeTask) score += 20
-
-    // Having tasks but not too many
-    if (stats.tasksInQueue > 0 && stats.tasksInQueue < 15) score += 15
-    if (stats.tasksInQueue >= 15) score -= 5 // Too many tasks
-
-    // Shipped features is great
-    score += Math.min(20, stats.featuresShipped * 5)
-
-    // Ideas are good but not critical
-    score += Math.min(10, stats.ideasCaptured * 2)
-
-    score = Math.max(0, Math.min(100, score))
-
-    let message = ''
-    if (score >= 80) message = '🟢 Excellent - Great momentum!'
-    else if (score >= 60) message = '🟡 Good - Keep shipping!'
-    else if (score >= 40) message = '🟠 Fair - Need more activity'
-    else message = '🔴 Low - Time to get started!'
-
-    return { score, message }
+    // AGENTIC: Claude evaluates health via templates/analysis/health.md
+    // Simple calculation - real assessment happens in template execution
+    const hasActivity = stats.activeTask || stats.featuresShipped > 0
+    return {
+      score: hasActivity ? 70 : 50,
+      message: hasActivity ? '🟢 Active' : '🟡 Ready to start',
+    }
   }
 
   /**
@@ -1747,9 +1410,11 @@ Status: ⏸️  Planned
       console.log(`   Estimated: ${estimate}h`)
       console.log(`   Type: ${complexity.type}\n`)
 
-      // Auto-assign agent (simplified)
-      const agent = this._autoAssignAgent(task)
-      console.log(`🤖 Agent: ${agent}\n`)
+      // MANDATORY: Assign agent using router
+      const agentResult = await this._assignAgentForTask(task, projectPath, context)
+      const agent = agentResult.agent?.name || 'generalist'
+      const confidence = agentResult.routing?.confidence || 0.5
+      console.log(`🤖 Agent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`)
 
       // Set as current task with metadata
       const nowContentNew = `# NOW
@@ -1759,7 +1424,7 @@ Status: ⏸️  Planned
 Started: ${new Date().toLocaleString()}
 Estimated: ${estimate}h
 Complexity: ${complexity.level}
-Agent: ${agent}
+Agent: ${agent} (${Math.round(confidence * 100)}% confidence)
 `
       await toolRegistry.get('Write')(context.paths.now, nowContentNew)
 
@@ -1774,6 +1439,7 @@ Agent: ${agent}
         complexity: complexity.level,
         estimate,
         agent,
+        confidence,
         timestamp: dateHelper.getTimestamp(),
       })
 
@@ -1789,72 +1455,64 @@ Agent: ${agent}
    * @private
    */
   _detectComplexity(task) {
-    const lowerTask = task.toLowerCase()
-
-    // Type detection
-    let type = 'general'
-    if (lowerTask.includes('fix') || lowerTask.includes('bug')) type = 'bugfix'
-    else if (lowerTask.includes('test')) type = 'testing'
-    else if (lowerTask.includes('refactor')) type = 'refactoring'
-    else if (lowerTask.includes('implement') || lowerTask.includes('add')) type = 'feature'
-    else if (lowerTask.includes('design')) type = 'design'
-
-    // Complexity indicators
-    const complexityIndicators = {
-      high: ['architecture', 'redesign', 'migration', 'integration', 'authentication', 'database'],
-      medium: ['api', 'component', 'service', 'endpoint', 'feature'],
-      low: ['fix', 'update', 'modify', 'adjust', 'tweak'],
-    }
+    // AGENTIC: Claude analyzes complexity via templates/analysis/complexity.md
+    // Returns default - real analysis happens in template execution
+    return { level: 'medium', hours: 4, type: 'feature' }
+  }
 
-    let level = 'medium'
-    let hours = 4
+  /**
+   * Assign agent for a task
+   * AGENTIC: Claude decides via templates/agent-assignment.md
+   * JS only orchestrates: load agents → build context → delegate to Claude
+   * @private
+   */
+  async _assignAgentForTask(taskDescription, projectPath, context) {
+    try {
+      const projectId = await configManager.getProjectId(projectPath)
 
-    for (const [levelKey, indicators] of Object.entries(complexityIndicators)) {
-      if (indicators.some((indicator) => lowerTask.includes(indicator))) {
-        level = levelKey
-        break
+      // ORCHESTRATION ONLY: Load available agents
+      const agentsPath = pathManager.getPath(projectId, 'agents')
+      const agentFiles = await fileHelper.listFiles(agentsPath, '.md')
+      const agents = agentFiles.map(f => f.replace('.md', ''))
+
+      // ORCHESTRATION ONLY: Build context for Claude
+      const assignmentContext = {
+        task: taskDescription,
+        agents: agents.join(', ') || 'generalist',
+        projectPath,
+        // Claude will use this context + template to decide
       }
-    }
-
-    // Estimate hours
-    if (level === 'high') hours = 8
-    else if (level === 'medium') hours = 4
-    else hours = 2
 
-    return { level, hours, type }
+      // AGENTIC: Claude decides agent via template
+      // The template templates/agent-assignment.md guides Claude's decision
+      // For now, return structure that prompt-builder will use with template
+      return {
+        agent: { name: agents[0] || 'generalist', domain: 'auto' },
+        routing: {
+          confidence: 0.8,
+          reason: 'Claude assigns via templates/agent-assignment.md',
+          availableAgents: agents
+        },
+        _agenticNote: 'Use templates/agent-assignment.md for actual assignment'
+      }
+    } catch (error) {
+      // Fallback - still return structure
+      return {
+        agent: { name: 'generalist', domain: 'general' },
+        routing: { confidence: 0.5, reason: 'Fallback - no agents found' }
+      }
+    }
   }
 
   /**
-   * Auto-assign agent based on task
+   * Auto-assign agent based on task (sync wrapper for backward compat)
+   * DEPRECATED: Use _assignAgentForTask instead
    * @private
    */
   _autoAssignAgent(task) {
-    const lowerTask = task.toLowerCase()
-
-    if (
-      lowerTask.includes('ui') ||
-      lowerTask.includes('component') ||
-      lowerTask.includes('frontend')
-    ) {
-      return 'frontend-specialist'
-    }
-    if (
-      lowerTask.includes('api') ||
-      lowerTask.includes('backend') ||
-      lowerTask.includes('database')
-    ) {
-      return 'backend-specialist'
-    }
-    if (lowerTask.includes('test')) {
-      return 'qa-specialist'
-    }
-    if (lowerTask.includes('design') || lowerTask.includes('architecture')) {
-      return 'architect'
-    }
-    if (lowerTask.includes('deploy') || lowerTask.includes('docker')) {
-      return 'devops-specialist'
-    }
-
+    // For backward compatibility, return generalist synchronously
+    // New code should use _assignAgentForTask() which is async
+    console.warn('DEPRECATED: Use _assignAgentForTask() for proper agent routing')
     return 'generalist'
   }