prjct-cli 0.9.2 → 0.10.0

package/core/domain/agent-generator.js

@@ -1,6 +1,7 @@
 const fs = require('fs').promises
 const path = require('path')
 const os = require('os')
+const AgentLoader = require('./agent-loader')
 
 /**
  * AgentGenerator - Universal Dynamic Agent Generation
@@ -13,6 +14,7 @@ class AgentGenerator {
     this.outputDir = projectId
       ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
       : path.join(os.homedir(), '.prjct-cli', 'agents')
+    this.loader = new AgentLoader(projectId)
   }
 
   /**
@@ -23,62 +25,64 @@ class AgentGenerator {
     console.log(`   🤖 Generating ${agentName} agent...`)
     await fs.mkdir(this.outputDir, { recursive: true })
 
-    // Extract technologies dynamically
-    const techs = this.detectTechnologies(config)
-    const expertise = this.buildExpertise(techs, config)
-
     // Generate concise, actionable agent prompt
-    const content = `You are ${config.role || agentName}.
-
-EXPERTISE: ${expertise}
-
-FOCUS: ${config.contextFilter || 'Only relevant files'}
-
-AUTHORITY: Make decisions. Don't ask permission. Execute.
-
-RULES:
-- Stay in your domain
-- Use best practices for ${techs.join(', ') || 'detected tech'}
-- Optimize for production
-- No explanations unless asked`
+    const content = this.buildAgentPrompt(agentName, config)
 
     const outputPath = path.join(this.outputDir, `${agentName}.md`)
     await fs.writeFile(outputPath, content, 'utf-8')
     console.log(`   ✅ ${agentName} agent created`)
 
-    return { name: agentName, expertise, techs }
-  }
-
-  /**
-   * Detect technologies from config/analysis
-   */
-  detectTechnologies(config) {
-    const techs = []
-
-    // Extract from various sources
-    if (config.techStack) techs.push(...config.techStack.languages || [])
-    if (config.frameworks) techs.push(...config.frameworks)
-    if (config.expertise) {
-      // Parse expertise string for tech keywords
-      const keywords = config.expertise.toLowerCase()
-      const knownTechs = ['ruby', 'rails', 'go', 'rust', 'python', 'django', 'react', 'vue', 'node', 'typescript', 'elixir', 'phoenix']
-      knownTechs.forEach(tech => {
-        if (keywords.includes(tech)) techs.push(tech)
-      })
-    }
-
-    return [...new Set(techs)]
+    return { name: agentName }
   }
 
   /**
-   * Build concise expertise string
+   * Build comprehensive agent prompt
    */
-  buildExpertise(techs, config) {
-    const tech = techs.length > 0 ? techs.join(', ') : 'detected stack'
-    const domain = config.domain || 'assigned domain'
-    const focus = config.responsibilities || 'task at hand'
-
-    return `${tech} expert. ${domain}. Focus: ${focus}`
+  buildAgentPrompt(agentName, config) {
+    const domain = config.domain || 'general';
+    
+    const projectContext = (typeof config.projectContext === 'object')
+      ? JSON.stringify(config.projectContext || {}, null, 2)
+      : (config.projectContext || 'No specific project context provided.');
+
+    return `# AGENT: ${agentName.toUpperCase()}
+Role: ${config.role || agentName}
+
+## META-INSTRUCTION
+You are an intelligent agent responsible for this domain.
+Your first task is to ANALYZE the provided PROJECT CONTEXT to determine:
+1. The technology stack being used.
+2. The architectural patterns in place.
+3. The specific best practices relevant to this stack.
+
+## DOMAIN AUTHORITY
+You are the owner of the ${domain} domain.
+You have full authority to make technical decisions within this scope.
+
+## DYNAMIC STANDARDS
+Instead of following a hardcoded list, you must:
+- **DETECT**: Identify the languages, frameworks, and tools from the file extensions and content.
+- **ADAPT**: Adopt the persona of a Senior Engineer specializing in the detected stack.
+- **ENFORCE**: Apply the idiomatic best practices, naming conventions, and patterns of that stack.
+
+## ORCHESTRATION PROTOCOL
+1. **ANALYZE**: Read the context. Determine the stack.
+2. **PLAN**: Create a plan that fits the detected architecture.
+3. **EXECUTE**: Implement using the detected tools and patterns.
+4. **VERIFY**: Ensure code matches the project's existing style.
+
+## PROJECT CONTEXT
+${projectContext}
+
+## CONTEXT FOCUS
+${config.contextFilter || 'Only relevant files'}
+
+## RULES
+- Stay in your domain (${domain})
+- Do not assume a specific stack until you see the code.
+- Optimize for production.
+- No explanations unless asked.
+`;
   }
 
   /**
@@ -124,6 +128,33 @@ RULES:
       return []
     }
   }
+
+  /**
+   * Load an agent from its file
+   * CRITICAL: This is how agents are actually used in prompts
+   * @param {string} agentName - Name of the agent (without .md extension)
+   * @returns {Promise<Object|null>} - Agent object with name, content, role, domain, skills, or null if not found
+   */
+  async loadAgent(agentName) {
+    return await this.loader.loadAgent(agentName)
+  }
+
+  /**
+   * Load all agents for the project
+   * @returns {Promise<Array<Object>>} - Array of agent objects
+   */
+  async loadAllAgents() {
+    return await this.loader.loadAllAgents()
+  }
+
+  /**
+   * Check if an agent exists
+   * @param {string} agentName - Name of the agent
+   * @returns {Promise<boolean>} - True if agent file exists
+   */
+  async agentExists(agentName) {
+    return await this.loader.agentExists(agentName)
+  }
 }
 
 module.exports = AgentGenerator

package/core/domain/agent-loader.js

@@ -0,0 +1,183 @@
+/**
+ * AgentLoader - Loads agents from project files
+ * 
+ * CRITICAL: This ensures agents generated for a project are actually USED
+ * 
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+class AgentLoader {
+  constructor(projectId = null) {
+    this.projectId = projectId
+    this.agentsDir = projectId
+      ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
+      : path.join(os.homedir(), '.prjct-cli', 'agents')
+    this.cache = new Map()
+  }
+
+  /**
+   * Load an agent from its file
+   * @param {string} agentName - Name of the agent (without .md extension)
+   * @returns {Promise<Object|null>} - Agent object with name and content, or null if not found
+   */
+  async loadAgent(agentName) {
+    // Check cache first
+    const cacheKey = `${this.projectId || 'global'}-${agentName}`
+    if (this.cache.has(cacheKey)) {
+      return this.cache.get(cacheKey)
+    }
+
+    try {
+      const agentPath = path.join(this.agentsDir, `${agentName}.md`)
+      const content = await fs.readFile(agentPath, 'utf-8')
+
+      // Parse agent metadata from content
+      const agent = {
+        name: agentName,
+        content,
+        path: agentPath,
+        // Extract role if present in content
+        role: this.extractRole(content),
+        // Extract domain if present
+        domain: this.extractDomain(content),
+        // Extract skills/technologies mentioned
+        skills: this.extractSkills(content),
+        // Last modified time
+        modified: (await fs.stat(agentPath)).mtime
+      }
+
+      // Cache it
+      this.cache.set(cacheKey, agent)
+
+      return agent
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return null // Agent file doesn't exist
+      }
+      throw error
+    }
+  }
+
+  /**
+   * Load all agents for the project
+   * @returns {Promise<Array<Object>>} - Array of agent objects
+   */
+  async loadAllAgents() {
+    try {
+      const files = await fs.readdir(this.agentsDir)
+      const agentFiles = files.filter(f => f.endsWith('.md') && !f.startsWith('.'))
+
+      const agents = []
+      for (const file of agentFiles) {
+        const agentName = file.replace('.md', '')
+        const agent = await this.loadAgent(agentName)
+        if (agent) {
+          agents.push(agent)
+        }
+      }
+
+      return agents
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        return [] // Agents directory doesn't exist yet
+      }
+      throw error
+    }
+  }
+
+  /**
+   * Check if an agent exists
+   * @param {string} agentName - Name of the agent
+   * @returns {Promise<boolean>} - True if agent file exists
+   */
+  async agentExists(agentName) {
+    try {
+      const agentPath = path.join(this.agentsDir, `${agentName}.md`)
+      await fs.access(agentPath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Clear cache (useful after agent updates)
+   */
+  clearCache() {
+    this.cache.clear()
+  }
+
+  /**
+   * Extract role from agent content
+   * @private
+   */
+  extractRole(content) {
+    const roleMatch = content.match(/Role:\s*(.+)/i)
+    return roleMatch ? roleMatch[1].trim() : null
+  }
+
+  /**
+   * Extract domain from agent content
+   * @private
+   */
+  extractDomain(content) {
+    const domainMatch = content.match(/DOMAIN AUTHORITY[\s\S]*?the\s+(\w+)\s+domain/i)
+    if (domainMatch) {
+      return domainMatch[1].toLowerCase()
+    }
+    
+    // Fallback: try to detect from agent name
+    const name = this.projectId ? '' : ''
+    if (name.includes('frontend')) return 'frontend'
+    if (name.includes('backend')) return 'backend'
+    if (name.includes('database')) return 'database'
+    if (name.includes('devops')) return 'devops'
+    if (name.includes('qa')) return 'qa'
+    if (name.includes('architect')) return 'architecture'
+    
+    return 'general'
+  }
+
+  /**
+   * Extract skills/technologies mentioned in agent content
+   * @private
+   */
+  extractSkills(content) {
+    const skills = []
+    
+    // Look for common technology mentions
+    const techKeywords = [
+      'React', 'Vue', 'Angular', 'Svelte',
+      'Next.js', 'Nuxt', 'SvelteKit',
+      'TypeScript', 'JavaScript',
+      'Node.js', 'Express', 'Fastify',
+      'Python', 'Django', 'Flask', 'FastAPI',
+      'Go', 'Rust', 'Ruby', 'Rails',
+      'PostgreSQL', 'MySQL', 'MongoDB',
+      'Docker', 'Kubernetes', 'Terraform'
+    ]
+
+    for (const tech of techKeywords) {
+      if (content.includes(tech)) {
+        skills.push(tech)
+      }
+    }
+
+    return skills
+  }
+
+  /**
+   * Get agents directory path
+   * @returns {string} - Path to agents directory
+   */
+  getAgentsDir() {
+    return this.agentsDir
+  }
+}
+
+module.exports = AgentLoader
+

package/core/domain/agent-matcher.js

@@ -0,0 +1,217 @@
+/**
+ * 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
+ */
+
+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
+  }
+
+  /**
+   * Score skills match
+   */
+  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
+  }
+
+  /**
+   * Score historical success
+   */
+  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
+  }
+
+  /**
+   * Score complexity match
+   */
+  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
+    }
+
+    return 0.5 // Neutral
+  }
+
+  /**
+   * Record agent success for learning
+   */
+  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++
+    }
+    history.successRate = history.successes / history.attempts
+
+    this.historyCache.set(cacheKey, history)
+  }
+
+  /**
+   * Get match explanation
+   */
+  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')
+    }
+
+    return reasons.join(', ')
+  }
+}
+
+module.exports = AgentMatcher
+