prjct-cli 0.10.11 → 0.10.13

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(' ')
 
-      return { success: true, feature: description, tasks }
+      out.done(`${tasks.length} tasks [${agentSummary}]`)
+
+      return { success: true, feature: description, tasks: tasksWithAgents }
     } catch (error) {
       out.fail(error.message)
       return { success: false, error: error.message }
@@ -488,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 =
@@ -501,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 }
@@ -1378,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
@@ -1390,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)
 
@@ -1405,6 +1439,7 @@ Agent: ${agent}
         complexity: complexity.level,
         estimate,
         agent,
+        confidence,
         timestamp: dateHelper.getTimestamp(),
       })
 
@@ -1426,12 +1461,58 @@ Agent: ${agent}
   }
 
   /**
-   * Auto-assign agent based on task
+   * 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)
+
+      // 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
+      }
+
+      // 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 (sync wrapper for backward compat)
+   * DEPRECATED: Use _assignAgentForTask instead
    * @private
    */
   _autoAssignAgent(task) {
-    // AGENTIC: Agent assignment handled by agent-router.js with semantic analysis
-    // Returns default - real routing happens via MandatoryAgentRouter
+    // 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'
   }
 
@@ -1844,6 +1925,15 @@ Agent: ${agent}
       console.log(`⚠️  ${configResult.error}`)
     }
 
+    // Install status line for Claude Code
+    console.log('\n⚡ Installing status line...')
+    const statusLineResult = await this.installStatusLine()
+    if (statusLineResult.success) {
+      console.log('✅ Status line configured')
+    } else {
+      console.log(`⚠️  ${statusLineResult.error}`)
+    }
+
     console.log('\n🎉 Setup complete!\n')
 
     // Show beautiful ASCII art
@@ -1855,6 +1945,69 @@ Agent: ${agent}
     }
   }
 
+  /**
+   * Install status line script and configure settings.json
+   */
+  async installStatusLine() {
+    const fs = require('fs')
+    const path = require('path')
+    const os = require('os')
+
+    try {
+      const claudeDir = path.join(os.homedir(), '.claude')
+      const settingsPath = path.join(claudeDir, 'settings.json')
+      const statusLinePath = path.join(claudeDir, 'prjct-statusline.sh')
+
+      // Copy status line script
+      const scriptContent = `#!/bin/bash
+# prjct Status Line for Claude Code
+# Shows ⚡ prjct with animated spinner when command is running
+
+# Read JSON context from stdin (provided by Claude Code)
+read -r json
+
+# Spinner frames
+frames=('⠋' '⠙' '⠹' '⠸' '⠼' '⠴' '⠦' '⠧' '⠇' '⠏')
+
+# Calculate frame based on time (changes every 80ms)
+frame=$(($(date +%s%N 2>/dev/null || echo 0) / 80000000 % 10))
+
+# Check if prjct command is running
+running_file="$HOME/.prjct-cli/.running"
+
+if [ -f "$running_file" ]; then
+  task=$(cat "$running_file" 2>/dev/null || echo "working")
+  echo "⚡ prjct \${frames[$frame]} $task"
+else
+  echo "⚡ prjct"
+fi
+`
+      fs.writeFileSync(statusLinePath, scriptContent, { mode: 0o755 })
+
+      // Update settings.json
+      let settings = {}
+      if (fs.existsSync(settingsPath)) {
+        try {
+          settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'))
+        } catch {
+          // Invalid JSON, start fresh
+        }
+      }
+
+      // Set status line configuration
+      settings.statusLine = {
+        type: 'command',
+        command: statusLinePath
+      }
+
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2))
+
+      return { success: true }
+    } catch (error) {
+      return { success: false, error: error.message }
+    }
+  }
+
   /**
    * Show beautiful ASCII art with quick start
    */

package/core/domain/agent-matcher.js

@@ -1,217 +1,103 @@
 /**
- * AgentMatcher - Intelligent Agent Matching with Scoring
- * 
- * Matches tasks to agents using multi-factor scoring:
- * - Agent skills and capabilities
- * - Historical success rates
- * - Project technologies
- * - Task complexity
- * 
- * @version 1.0.0
+ * AgentMatcher - Orchestration Only
+ *
+ * AGENTIC: All matching decisions made by Claude via templates/agent-assignment.md
+ * JS only orchestrates: format data, pass to Claude, return result
+ *
+ * NO scoring logic, NO algorithms, NO hardcoded weights
+ *
+ * @version 2.0.0
  */
 
+const fs = require('fs').promises
+const path = require('path')
+
 class AgentMatcher {
   constructor() {
-    this.historyCache = new Map()
-  }
-
-  /**
-   * Find best agent for a task using intelligent scoring
-   * @param {Array<Object>} availableAgents - All available agents
-   * @param {Object} taskAnalysis - Task analysis result
-   * @returns {Object|null} Best matching agent with score
-   */
-  findBestAgent(availableAgents, taskAnalysis) {
-    if (!availableAgents || availableAgents.length === 0) {
-      return null
-    }
-
-    // Score each agent
-    const scored = availableAgents.map(agent => {
-      const score = this.scoreAgent(agent, taskAnalysis)
-      return { agent, score }
-    })
-
-    // Sort by score descending
-    scored.sort((a, b) => b.score - a.score)
-
-    // Return best match if score is above threshold
-    const best = scored[0]
-    if (best && best.score > 0.3) {
-      return {
-        agent: best.agent,
-        score: best.score,
-        alternatives: scored.slice(1, 3).map(s => ({
-          agent: s.agent,
-          score: s.score
-        }))
-      }
-    }
-
-    return null
-  }
-
-  /**
-   * Score an agent for a specific task
-   * Multi-factor scoring system
-   */
-  scoreAgent(agent, taskAnalysis) {
-    let score = 0
-
-    // Factor 1: Domain Match (40% weight)
-    const domainScore = this.scoreDomainMatch(agent, taskAnalysis)
-    score += domainScore * 0.4
-
-    // Factor 2: Skills Match (30% weight)
-    const skillsScore = this.scoreSkillsMatch(agent, taskAnalysis)
-    score += skillsScore * 0.3
-
-    // Factor 3: Historical Success (20% weight)
-    const historyScore = this.scoreHistoricalSuccess(agent, taskAnalysis)
-    score += historyScore * 0.2
-
-    // Factor 4: Complexity Match (10% weight)
-    const complexityScore = this.scoreComplexityMatch(agent, taskAnalysis)
-    score += complexityScore * 0.1
-
-    return Math.min(score, 1.0)
-  }
-
-  /**
-   * Score domain match
-   */
-  scoreDomainMatch(agent, taskAnalysis) {
-    const agentDomain = agent.domain || ''
-    const taskDomain = taskAnalysis.primaryDomain || ''
-
-    // Exact match
-    if (agentDomain === taskDomain) {
-      return 1.0
-    }
-
-    // Partial match (agent name contains domain)
-    if (agent.name && agent.name.includes(taskDomain)) {
-      return 0.7
-    }
-
-    // Check alternatives
-    if (taskAnalysis.alternatives && taskAnalysis.alternatives.includes(agentDomain)) {
-      return 0.5
-    }
-
-    return 0.1
+    this.historyPath = null
   }
 
   /**
-   * Score skills match
+   * Set history path for logging
+   * ORCHESTRATION: Path setup only
    */
-  scoreSkillsMatch(agent, taskAnalysis) {
-    if (!agent.skills || agent.skills.length === 0) {
-      return 0.2 // Generic agent penalty
-    }
-
-    const projectTech = taskAnalysis.projectTechnologies || {}
-    const allTech = [
-      ...(projectTech.languages || []),
-      ...(projectTech.frameworks || []),
-      ...(projectTech.tools || [])
-    ]
-
-    // Count matching skills
-    const matchingSkills = agent.skills.filter(skill => {
-      const skillLower = skill.toLowerCase()
-      return allTech.some(tech => tech.toLowerCase().includes(skillLower) || 
-                                  skillLower.includes(tech.toLowerCase()))
-    })
-
-    if (matchingSkills.length === 0) {
-      return 0.1 // No matching skills
-    }
-
-    // Score based on match ratio
-    const matchRatio = matchingSkills.length / Math.max(agent.skills.length, allTech.length)
-    return Math.min(matchRatio * 2, 1.0) // Boost for good matches
+  setHistoryPath(projectId) {
+    this.historyPath = path.join(
+      process.env.HOME,
+      '.prjct-cli',
+      'projects',
+      projectId,
+      'agent-history.jsonl'
+    )
   }
 
   /**
-   * Score historical success
+   * Format agents for Claude
+   * ORCHESTRATION: Data formatting only
    */
-  scoreHistoricalSuccess(agent, taskAnalysis) {
-    // TODO: Load from persistent history
-    // For now, return neutral score
-    const cacheKey = `${agent.name}-${taskAnalysis.primaryDomain}`
-    const history = this.historyCache.get(cacheKey)
-
-    if (history) {
-      // Success rate from history
-      return history.successRate || 0.5
-    }
-
-    return 0.5 // Neutral - no history
+  formatAgentsForTemplate(agents) {
+    return agents.map(a => ({
+      name: a.name,
+      domain: a.domain || 'general',
+      hasContent: !!a.content
+    }))
   }
 
   /**
-   * Score complexity match
+   * Format task for Claude
+   * ORCHESTRATION: Data formatting only
    */
-  scoreComplexityMatch(agent, taskAnalysis) {
-    const taskComplexity = taskAnalysis.complexity || 'medium'
-    
-    // Generic agents are better for simple tasks
-    // Specialized agents are better for complex tasks
-    const isGeneric = !agent.skills || agent.skills.length === 0
-
-    if (taskComplexity === 'low' && isGeneric) {
-      return 0.8
-    }
-
-    if (taskComplexity === 'high' && !isGeneric) {
-      return 0.9
+  formatTaskForTemplate(task) {
+    return {
+      description: typeof task === 'string' ? task : task.description,
+      type: task.type || 'unknown'
     }
-
-    return 0.5 // Neutral
   }
 
   /**
-   * Record agent success for learning
+   * Record agent usage
+   * ORCHESTRATION: File I/O only
    */
-  recordSuccess(agent, taskAnalysis, success = true) {
-    const cacheKey = `${agent.name}-${taskAnalysis.primaryDomain}`
-    const history = this.historyCache.get(cacheKey) || {
-      attempts: 0,
-      successes: 0,
-      successRate: 0.5
-    }
-
-    history.attempts++
-    if (success) {
-      history.successes++
+  async recordUsage(agent, task) {
+    if (!this.historyPath) return
+
+    try {
+      const entry = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        agent: agent.name || agent,
+        task: typeof task === 'string' ? task : task.description
+      }) + '\n'
+
+      await fs.appendFile(this.historyPath, entry)
+    } catch {
+      // Silent fail
     }
-    history.successRate = history.successes / history.attempts
-
-    this.historyCache.set(cacheKey, history)
   }
 
   /**
-   * Get match explanation
+   * Load usage history
+   * ORCHESTRATION: File I/O only
    */
-  explainMatch(match) {
-    if (!match) {
-      return 'No suitable agent found'
-    }
-
-    const reasons = []
-
-    if (match.score > 0.8) {
-      reasons.push('Excellent match')
-    } else if (match.score > 0.6) {
-      reasons.push('Good match')
-    } else {
-      reasons.push('Acceptable match')
+  async loadHistory() {
+    if (!this.historyPath) return []
+
+    try {
+      const content = await fs.readFile(this.historyPath, 'utf-8')
+      return content
+        .split('\n')
+        .filter(Boolean)
+        .map(line => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter(Boolean)
+    } catch {
+      return []
     }
-
-    return reasons.join(', ')
   }
 }
 
 module.exports = AgentMatcher
-

package/core/index.js

@@ -6,6 +6,7 @@
 
 const { PrjctCommands } = require('./commands')
 const registry = require('./command-registry')
+const out = require('./utils/output')
 
 async function main() {
   const [commandName, ...rawArgs] = process.argv.slice(2)
@@ -25,6 +26,9 @@ async function main() {
 
   // === DYNAMIC COMMAND EXECUTION ===
 
+  // Show branding header
+  out.start()
+
   try {
     // 1. Find command in registry
     const cmd = registry.getByName(commandName)
@@ -32,6 +36,7 @@ async function main() {
     if (!cmd) {
       console.error(`Unknown command: ${commandName}`)
       console.error(`\nUse 'prjct --help' to see available commands.`)
+      out.end()
       process.exit(1)
     }
 
@@ -41,6 +46,7 @@ async function main() {
       if (cmd.replacedBy) {
         console.error(`Use 'prjct ${cmd.replacedBy}' instead.`)
       }
+      out.end()
       process.exit(1)
     }
 
@@ -49,6 +55,7 @@ async function main() {
       console.error(`Command '${commandName}' exists but is not yet implemented.`)
       console.error(`Check the roadmap or contribute: https://github.com/jlopezlira/prjct-cli`)
       console.error(`\nUse 'prjct --help' to see available commands.`)
+      out.end()
       process.exit(1)
     }
 
@@ -90,12 +97,16 @@ async function main() {
       console.log(result.message)
     }
 
+    // Show branding footer
+    out.end()
     process.exit(result && result.success ? 0 : 1)
   } catch (error) {
     console.error('Error:', error.message)
     if (process.env.DEBUG) {
       console.error(error.stack)
     }
+    // Show branding footer even on error
+    out.end()
     process.exit(1)
   }
 }