prjct-cli 0.10.11 → 0.10.13

package/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.10.12] - 2025-11-29
+
+### Refactored - Mandatory Agent Assignment (100% Agentic)
+
+All agent assignment decisions now delegated to Claude via templates. JS code is pure orchestration.
+
+- **New Template**: `templates/agent-assignment.md`
+  - Claude decides which agent based on task + available agents + context
+  - No hardcoded scoring weights or matching algorithms
+  - Semantic understanding replaces keyword matching
+
+- **Simplified `agent-router.js`**: 419 → 128 lines (69% reduction)
+  - Removed: scoring logic, domain mappings, caching algorithms
+  - Kept: load agents, build context, log usage (I/O only)
+  - Class renamed: `MandatoryAgentRouter` → `AgentRouter`
+
+- **Simplified `agent-matcher.js`**: 218 → 103 lines (53% reduction)
+  - Removed: multi-factor scoring (40% domain, 30% skills, etc.)
+  - Removed: all if/else matching logic
+  - Kept: format data, record usage, load history (I/O only)
+
+- **Updated commands.js**:
+  - `/p:now` - Assigns agent before setting task, shows `[agent]`
+  - `/p:feature` - Assigns agent to each task, format: `[agent] [ ] task`
+  - `/p:bug` - Assigns agent, shows `→ agent`
+  - `/p:build` - Uses async `_assignAgentForTask()`
+  - New method: `_assignAgentForTask()` - orchestrates agent assignment
+
+### Architecture Principle
+
+**JS = Orchestrator** (load files, build context, format data, I/O)
+**Claude = Decision Maker** (via templates for all logic)
+
+No scoring algorithms, no matching weights, no domain mappings in code.
+
 ## [0.10.11] - 2025-11-29
 
 ### Refactored - 100% Agentic System

package/core/agentic/agent-router.js

@@ -1,421 +1,128 @@
 /**
- * Mandatory Agent Router
+ * Agent Router - Orchestration Only
  *
- * CRITICAL: Ensures EVERY task is executed by a specialized agent
- * No task can run without an assigned expert agent
+ * AGENTIC: All decisions made by Claude via templates/agent-assignment.md
+ * JS only orchestrates: load agents, build context, delegate to Claude
  *
- * @version 1.0.0
+ * NO scoring logic, NO matching algorithms, NO hardcoded mappings
+ *
+ * @version 2.0.0
  */
 
-const fs = require('fs').promises;
-const path = require('path');
-const AgentGenerator = require('../domain/agent-generator');
-const configManager = require('../infrastructure/config-manager');
-const TaskAnalyzer = require('../domain/task-analyzer');
-const AgentMatcher = require('../domain/agent-matcher');
-const SmartCache = require('../domain/smart-cache');
-const AgentValidator = require('../domain/agent-validator');
-const log = require('../utils/logger');
+const fs = require('fs').promises
+const path = require('path')
+const configManager = require('../infrastructure/config-manager')
+const pathManager = require('../infrastructure/path-manager')
 
-class MandatoryAgentRouter {
+class AgentRouter {
   constructor() {
-    this.agentGenerator = null; // Will be initialized with projectId
-    this.agentCache = null; // SmartCache instance
-    this.usageLog = [];
-    this.projectId = null;
-    this.taskAnalyzer = null;
-    this.agentMatcher = new AgentMatcher();
-    this.agentValidator = new AgentValidator();
+    this.projectId = null
+    this.agentsPath = null
   }
 
   /**
    * Initialize with project context
-   * @param {string} projectPath - Path to the project
+   * ORCHESTRATION: Just sets up paths
    */
   async initialize(projectPath) {
-    this.projectId = await configManager.getProjectId(projectPath);
-    this.agentGenerator = new AgentGenerator(this.projectId);
-    this.agentCache = new SmartCache(this.projectId);
-    await this.agentCache.initialize();
-    this.taskAnalyzer = new TaskAnalyzer(projectPath);
-    await this.taskAnalyzer.initialize();
+    this.projectId = await configManager.getProjectId(projectPath)
+    this.agentsPath = pathManager.getPath(this.projectId, 'agents')
   }
 
   /**
-   * Main entry point - ALL tasks MUST go through here
-   * @throws {Error} If no agent can be assigned
+   * Load all available agents from project
+   * ORCHESTRATION: File I/O only, no logic
    */
-  async executeTask(task, context, projectPath) {
-    // Initialize if needed
-    if (!this.agentGenerator) {
-      await this.initialize(projectPath);
-    }
-
-    // STEP 1: Deep semantic task analysis (NEW)
-    const taskAnalysis = await this.taskAnalyzer.analyzeTask(task);
-
-    // STEP 2: Select or generate specialized agent (MANDATORY) - with intelligent matching
-    const agent = await this.assignAgent(taskAnalysis, context, projectPath);
-
-    // STEP 3: Validate agent assignment
-    if (!agent || !agent.name) {
-      throw new Error(
-        `CRITICAL: No agent assigned for task "${task.description}".
-         System requires ALL tasks to use specialized agents.`
-      );
-    }
-
-    // STEP 4: Filter context for this specific agent
-    const filteredContext = await this.filterContextForAgent(
-      agent,
-      context,
-      taskAnalysis
-    );
-
-    // STEP 5: Log agent usage for tracking and learning
-    this.logAgentUsage(task, agent, filteredContext);
-    this.agentMatcher.recordSuccess(agent, taskAnalysis, true); // Learn from assignment
-
-    // STEP 6: Return agent with filtered context
-    return {
-      agent,
-      context: filteredContext,
-      taskAnalysis,
-      routing: {
-        reason: taskAnalysis.reason,
-        confidence: taskAnalysis.confidence,
-        alternativeAgents: taskAnalysis.alternatives
+  async loadAvailableAgents() {
+    try {
+      const files = await fs.readdir(this.agentsPath)
+      const agents = []
+
+      for (const file of files) {
+        if (file.endsWith('.md')) {
+          const name = file.replace('.md', '')
+          const content = await fs.readFile(
+            path.join(this.agentsPath, file),
+            'utf-8'
+          )
+          agents.push({ name, content })
+        }
       }
-    };
-  }
 
-  /**
-   * Analyze task to determine what type of expertise is needed
-   *
-   * 100% AGENTIC: Delegates to TaskAnalyzer which uses templates.
-   * NO hardcoded patterns or keyword lists.
-   */
-  async analyzeTask(task, projectPath = null) {
-    // Use TaskAnalyzer for semantic analysis (template-driven)
-    if (this.taskAnalyzer) {
-      return await this.taskAnalyzer.analyzeTask(task);
+      return agents
+    } catch {
+      return []
     }
-
-    // Fallback: Return minimal analysis, let Claude decide in prompt
-    return {
-      domain: 'generalist',
-      confidence: 0.5,
-      matchedKeywords: [],
-      reason: 'Using generalist - Claude will analyze task in context',
-      alternatives: ['full-stack'],
-      projectTechnologies: null
-    };
   }
 
   /**
-   * Assign the best agent for the task
-   * IMPROVED: Uses intelligent matching with scoring
+   * Get agent names list
+   * ORCHESTRATION: Simple extraction
    */
-  async assignAgent(taskAnalysis, context, projectPath, overrideAgent = null) {
-    // Respect override
-    if (overrideAgent) {
-      const existing = await this.agentGenerator.loadAgent(overrideAgent);
-      if (existing) {
-        return existing;
-      }
-      return this.generateSpecializedAgent(overrideAgent, {}, context);
-    }
-
-    const primaryDomain = taskAnalysis.primaryDomain;
-    const projectTech = taskAnalysis.projectTechnologies || {};
-
-    // Generate cache key with tech stack
-    const techStack = {
-      languages: projectTech.languages || [],
-      frameworks: projectTech.frameworks || []
-    };
-    const cacheKey = this.agentCache.generateKey(this.projectId, primaryDomain, techStack);
-
-    // Check smart cache first
-    const cached = await this.agentCache.get(cacheKey);
-    if (cached) {
-      return cached;
-    }
-
-    // STEP 1: Load all existing agents
-    const allAgents = await this.agentGenerator.loadAllAgents();
-
-    // STEP 2: Use intelligent matching to find best agent
-    const match = this.agentMatcher.findBestAgent(allAgents, taskAnalysis);
-
-    if (match && match.score > 0.5) {
-      // Good match found - use it
-      await this.agentCache.set(cacheKey, match.agent);
-      return match.agent;
-    }
-
-    // STEP 3: Try to load domain-specific agent
-    const agentType = this.getAgentTypeForDomain(primaryDomain);
-    const existingAgent = await this.agentGenerator.loadAgent(agentType);
-    
-    if (existingAgent) {
-      await this.agentCache.set(cacheKey, existingAgent);
-      return existingAgent;
-    }
-
-    // STEP 4: Validate before generating new agent
-    const config = {
-      domain: primaryDomain,
-      projectContext: context.projectSummary || context.projectContext || '',
-      expertise: this.buildExpertiseFromTech(projectTech, primaryDomain)
-    };
-
-    const validation = this.agentValidator.validateBeforeGeneration(
-      agentType,
-      config,
-      allAgents
-    );
-
-    if (!validation.valid && validation.similarAgent) {
-      // Similar agent exists - use it instead
-      await this.agentCache.set(cacheKey, validation.similarAgent);
-      return validation.similarAgent;
-    }
-
-    // STEP 5: Generate new agent only if validated
-    const agent = await this.generateSpecializedAgent(primaryDomain, techStack, context);
-    
-    // Validate after generation
-    const postValidation = this.agentValidator.validateAfterGeneration(agent);
-    if (!postValidation.valid) {
-      log.warn(`Agent validation issues: ${postValidation.issues.join(', ')}`);
-    }
-
-    // Cache for reuse
-    await this.agentCache.set(cacheKey, agent);
-
-    return agent;
+  async getAgentNames() {
+    const agents = await this.loadAvailableAgents()
+    return agents.map(a => a.name)
   }
 
   /**
-   * Build expertise string from tech stack
-   *
-   * 100% AGENTIC: No hardcoded framework lists.
-   * Returns ALL tech, Claude decides what's relevant.
+   * Load specific agent by name
+   * ORCHESTRATION: File I/O only
    */
-  buildExpertiseFromTech(projectTech, domain) {
-    const parts = []
-
-    // Include ALL languages - no filtering
-    if (projectTech.languages && projectTech.languages.length > 0) {
-      parts.push(projectTech.languages.join(', '))
-    }
-
-    // Include ALL frameworks - Claude decides relevance
-    // NO hardcoded lists like ['react', 'vue', 'angular']
-    if (projectTech.frameworks && projectTech.frameworks.length > 0) {
-      parts.push(projectTech.frameworks.join(', '))
-    }
-
-    // Include tools if present
-    if (projectTech.tools && projectTech.tools.length > 0) {
-      parts.push(projectTech.tools.join(', '))
+  async loadAgent(name) {
+    try {
+      const filePath = path.join(this.agentsPath, `${name}.md`)
+      const content = await fs.readFile(filePath, 'utf-8')
+      return { name, content }
+    } catch {
+      return null
     }
-
-    return parts.join(', ') || `${domain} development`
   }
 
   /**
-   * Get agent type name for a domain
-   * @private
-   */
-  getAgentTypeForDomain(domain) {
-    const agentTypes = {
-      frontend: 'frontend-specialist',
-      backend: 'backend-specialist',
-      database: 'database-specialist',
-      devops: 'devops-specialist',
-      qa: 'qa-specialist',
-      architecture: 'architect',
-      generalist: 'full-stack'
-    };
-    return agentTypes[domain] || 'full-stack';
-  }
-
-  /**
-   * Find similar agent from existing agents
-   * DEPRECATED: Now uses AgentMatcher for intelligent matching
-   * @private
-   */
-  findSimilarAgent(allAgents, domain, taskAnalysis) {
-    // Use AgentMatcher instead
-    const match = this.agentMatcher.findBestAgent(allAgents, taskAnalysis);
-    return match ? match.agent : null;
-  }
-
-  /**
-   * Generate a specialized agent for the detected domain
-   * Only called when no existing agent is found
-   */
-  async generateSpecializedAgent(domain, techStack, context) {
-    // Map domain to agent type
-    const agentType = this.getAgentTypeForDomain(domain);
-
-    // Generate with minimal config - let the Agent figure it out
-    const config = {
-      domain,
-      projectContext: context.projectSummary || context.projectContext || '',
-      // No hardcoded best practices passed here
-    };
-
-    // Generate the agent file
-    await this.agentGenerator.generateDynamicAgent(agentType, config);
-    
-    // Load it immediately so we return the full agent object
-    const agent = await this.agentGenerator.loadAgent(agentType);
-    
-    // If loading failed, return minimal object
-    return agent || { name: agentType, content: '', domain };
-  }
-
-  /**
-   * Filter context to only what's relevant for this agent
+   * Build context for agent assignment
+   * ORCHESTRATION: Data gathering only
    *
-   * 100% AGENTIC: No hardcoded directory/extension lists.
-   * Only excludes universal noise (node_modules, .git, dist).
-   * Claude decides relevance based on task.
-   */
-  async filterContextForAgent(agent, fullContext, taskAnalysis) {
-    // Universal exclusions that apply to ALL projects
-    const universalExclusions = ['node_modules', '.git', 'dist', 'build', '.next', 'target', 'vendor'];
-
-    // Filter only universal noise - let Claude decide the rest
-    const filtered = {
-      ...fullContext,
-      files: (fullContext.files || []).filter(file =>
-        !universalExclusions.some(exc => file.includes(exc))
-      ),
-      relevantOnly: false, // Claude decides relevance, not us
-      filterApplied: 'universal-only'
-    };
-
-    return filtered;
-  }
-
-  /**
-   * Filter files based on patterns
+   * Claude uses this context + templates/agent-assignment.md to decide
    */
-  filterFiles(files, pattern) {
-    return files.filter(file => {
-      // Check if file should be excluded
-      const isExcluded = pattern.exclude.some(exclude => file.includes(exclude));
-      if (isExcluded) return false;
-
-      // Check if file matches include patterns
-      if (pattern.include.length > 0) {
-        const isIncluded = pattern.include.some(include => file.includes(include));
-        if (!isIncluded) return false;
-      }
-
-      // Check extensions if specified
-      if (pattern.extensions.length > 0) {
-        const hasValidExtension = pattern.extensions.some(ext => file.endsWith(ext));
-        if (!hasValidExtension) return false;
-      }
+  async buildAssignmentContext(task, projectPath) {
+    const agents = await this.getAgentNames()
 
-      return true;
-    });
-  }
-
-  /**
-   * Log agent usage for metrics and optimization
-   */
-  logAgentUsage(task, agent, context) {
-    const usage = {
-      timestamp: new Date().toISOString(),
-      task: task.description,
-      agent: agent.name,
-      domain: agent.domain || 'unknown',
-      contextSize: context.files?.length || 0,
-      contextReduction: this.calculateContextReduction(context),
-      confidence: agent.confidence || 1.0
-    };
-
-    this.usageLog.push(usage);
-
-    // Also append to a log file for persistence
-    this.appendToLogFile(usage);
-
-    return usage;
-  }
-
-  /**
-   * Calculate how much context was reduced
-   */
-  calculateContextReduction(filteredContext) {
-    // This would compare against full context
-    // For now, estimate based on filtering
-    if (filteredContext.relevantOnly) {
-      return '70-90%'; // Typical reduction when filtering
+    return {
+      task: task.description || task,
+      availableAgents: agents,
+      projectPath,
+      projectId: this.projectId,
+      // Claude reads this and decides via template
+      _template: 'templates/agent-assignment.md'
     }
-    return '0%';
   }
 
   /**
-   * Append usage to log file
+   * Log agent usage
+   * ORCHESTRATION: File I/O only
    */
-  async appendToLogFile(usage) {
+  async logUsage(task, agent, projectPath) {
     try {
       const logPath = path.join(
         process.env.HOME,
         '.prjct-cli',
+        'projects',
+        this.projectId,
         'agent-usage.jsonl'
-      );
-
-      const logEntry = JSON.stringify(usage) + '\n';
-      await fs.appendFile(logPath, logEntry);
-    } catch (error) {
-      log.error('Failed to log agent usage:', error.message);
+      )
+
+      const entry = JSON.stringify({
+        timestamp: new Date().toISOString(),
+        task: typeof task === 'string' ? task : task.description,
+        agent: agent.name || agent,
+        projectId: this.projectId
+      }) + '\n'
+
+      await fs.appendFile(logPath, entry)
+    } catch {
+      // Silent fail for logging
     }
   }
-
-  /**
-   * Get similar domains for fallback
-   *
-   * 100% AGENTIC: Returns generic fallback.
-   * Claude determines domain relationships based on context.
-   */
-  getSimilarDomains(domain) {
-    // No hardcoded domain relationships
-    // Claude decides what's similar based on actual project context
-    return ['full-stack', 'generalist'];
-  }
-
-  /**
-   * Get usage statistics
-   */
-  getUsageStats() {
-    const stats = {
-      totalTasks: this.usageLog.length,
-      byAgent: {},
-      avgContextReduction: '0%',
-      mostUsedAgent: null
-    };
-
-    // Calculate stats from usage log
-    this.usageLog.forEach(log => {
-      stats.byAgent[log.agent] = (stats.byAgent[log.agent] || 0) + 1;
-    });
-
-    // Find most used agent
-    const mostUsed = Object.entries(stats.byAgent).reduce((max, [agent, count]) => {
-      return count > max.count ? { agent, count } : max;
-    }, { agent: null, count: 0 });
-
-    stats.mostUsedAgent = mostUsed.agent;
-
-    return stats;
-  }
 }
 
-module.exports = MandatoryAgentRouter;
+module.exports = AgentRouter

package/core/agentic/command-executor.js

@@ -15,6 +15,9 @@
  * Source: Claude Code, Devin, Augment Code patterns
  */
 
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
 const templateLoader = require('./template-loader')
 const contextBuilder = require('./context-builder')
 const promptBuilder = require('./prompt-builder')
@@ -32,6 +35,9 @@ const groundTruth = require('./ground-truth')
 const thinkBlocks = require('./think-blocks')
 const parallelTools = require('./parallel-tools')
 const planMode = require('./plan-mode')
+
+// Running file for status line integration
+const RUNNING_FILE = path.join(os.homedir(), '.prjct-cli', '.running')
 // P3.5, P3.6, P3.7: DELEGATED TO CLAUDE CODE
 // - semantic-search → Claude Code has Grep/Glob with semantic understanding
 // - code-intelligence → Claude Code has native LSP integration
@@ -44,16 +50,48 @@ class CommandExecutor {
     this.contextEstimator = null
   }
 
+  /**
+   * Signal that a command is running (for status line)
+   */
+  signalStart(commandName) {
+    try {
+      const dir = path.dirname(RUNNING_FILE)
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true })
+      }
+      fs.writeFileSync(RUNNING_FILE, `/p:${commandName}`)
+    } catch {
+      // Silently ignore - status line is optional
+    }
+  }
+
+  /**
+   * Signal that command has finished (for status line)
+   */
+  signalEnd() {
+    try {
+      if (fs.existsSync(RUNNING_FILE)) {
+        fs.unlinkSync(RUNNING_FILE)
+      }
+    } catch {
+      // Silently ignore - status line is optional
+    }
+  }
+
   /**
    * Execute command with MANDATORY agent assignment
    */
   async execute(commandName, params, projectPath) {
+    // Signal start for status line
+    this.signalStart(commandName)
+
     // Context for loop detection
     const loopContext = params.task || params.description || ''
 
     // Check if we're in a loop BEFORE attempting
     if (loopDetector.shouldEscalate(commandName, loopContext)) {
       const escalation = loopDetector.getEscalationInfo(commandName, loopContext)
+      this.signalEnd()
       return {
         success: false,
         error: escalation.message,
@@ -73,6 +111,7 @@ class CommandExecutor {
       // 2.5. VALIDATE: Pre-flight checks with specific errors
       const validation = await validate(commandName, metadataContext)
       if (!validation.valid) {
+        this.signalEnd()
         return {
           success: false,
           error: formatError(validation),
@@ -267,6 +306,9 @@ class CommandExecutor {
       // Record successful attempt
       loopDetector.recordSuccess(commandName, loopContext)
 
+      // Signal end for status line
+      this.signalEnd()
+
       return {
         success: true,
         template,
@@ -334,6 +376,9 @@ class CommandExecutor {
         // - Native LSP for code intelligence
       }
     } catch (error) {
+      // Signal end for status line
+      this.signalEnd()
+
       // Record failed attempt for loop detection
       const attemptInfo = loopDetector.recordAttempt(commandName, loopContext, {
         success: false,