prjct-cli 0.9.2 → 0.10.2

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
+

package/core/domain/agent-validator.js

@@ -0,0 +1,217 @@
+/**
+ * AgentValidator - Validates agents before and after generation
+ * 
+ * Ensures agents are useful and not generic
+ * Compares with existing agents before generating
+ * 
+ * @version 1.0.0
+ */
+
+class AgentValidator {
+  /**
+   * Validate if agent should be generated
+   * @param {string} agentName - Proposed agent name
+   * @param {Object} config - Agent configuration
+   * @param {Array<Object>} existingAgents - Existing agents
+   * @returns {Object} Validation result
+   */
+  validateBeforeGeneration(agentName, config, existingAgents = []) {
+    const issues = []
+    const warnings = []
+
+    // Check if similar agent exists
+    const similar = this.findSimilarAgent(agentName, config, existingAgents)
+    if (similar) {
+      warnings.push(`Similar agent exists: ${similar.name}`)
+    }
+
+    // Check if agent has specific skills
+    if (!config.expertise || config.expertise.length < 10) {
+      issues.push('Agent expertise is too generic')
+    }
+
+    // Check if agent has project context
+    if (!config.projectContext || Object.keys(config.projectContext).length === 0) {
+      warnings.push('Agent has no project-specific context')
+    }
+
+    // Check if agent name is descriptive
+    if (agentName.includes('specialist') && !config.expertise) {
+      issues.push('Agent name suggests specialization but has no expertise defined')
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues,
+      warnings,
+      similarAgent: similar
+    }
+  }
+
+  /**
+   * Validate agent after generation
+   * @param {Object} agent - Generated agent
+   * @returns {Object} Validation result
+   */
+  validateAfterGeneration(agent) {
+    const issues = []
+    const warnings = []
+
+    // Check if agent has content
+    if (!agent.content || agent.content.length < 100) {
+      issues.push('Agent content is too short or missing')
+    }
+
+    // Check if agent has skills extracted
+    if (!agent.skills || agent.skills.length === 0) {
+      warnings.push('Agent has no skills detected')
+    }
+
+    // Check if agent has domain
+    if (!agent.domain || agent.domain === 'general') {
+      warnings.push('Agent domain is generic')
+    }
+
+    // Check if agent is useful (not too generic)
+    const usefulness = this.calculateUsefulness(agent)
+    if (usefulness < 0.5) {
+      issues.push('Agent is too generic to be useful')
+    }
+
+    return {
+      valid: issues.length === 0,
+      issues,
+      warnings,
+      usefulness
+    }
+  }
+
+  /**
+   * Find similar existing agent
+   */
+  findSimilarAgent(agentName, config, existingAgents) {
+    for (const existing of existingAgents) {
+      // Check name similarity
+      if (this.namesSimilar(agentName, existing.name)) {
+        return existing
+      }
+
+      // Check domain similarity
+      if (config.domain && existing.domain && config.domain === existing.domain) {
+        // Check if skills overlap significantly
+        const skillOverlap = this.calculateSkillOverlap(config, existing)
+        if (skillOverlap > 0.7) {
+          return existing
+        }
+      }
+    }
+
+    return null
+  }
+
+  /**
+   * Check if agent names are similar
+   */
+  namesSimilar(name1, name2) {
+    const n1 = name1.toLowerCase()
+    const n2 = name2.toLowerCase()
+
+    // Exact match
+    if (n1 === n2) return true
+
+    // One contains the other
+    if (n1.includes(n2) || n2.includes(n1)) return true
+
+    // Check word overlap
+    const words1 = new Set(n1.split('-'))
+    const words2 = new Set(n2.split('-'))
+    const intersection = new Set([...words1].filter(w => words2.has(w)))
+    const union = new Set([...words1, ...words2])
+
+    return intersection.size / union.size > 0.5
+  }
+
+  /**
+   * Calculate skill overlap between config and existing agent
+   */
+  calculateSkillOverlap(config, existingAgent) {
+    if (!existingAgent.skills || existingAgent.skills.length === 0) {
+      return 0
+    }
+
+    // Extract skills from config expertise
+    const configSkills = this.extractSkillsFromText(config.expertise || '')
+    if (configSkills.length === 0) {
+      return 0
+    }
+
+    // Calculate overlap
+    const existingSet = new Set(existingAgent.skills.map(s => s.toLowerCase()))
+    const configSet = new Set(configSkills.map(s => s.toLowerCase()))
+
+    const intersection = new Set([...existingSet].filter(s => configSet.has(s)))
+    const union = new Set([...existingSet, ...configSet])
+
+    return intersection.size / union.size
+  }
+
+  /**
+   * Extract skills from text
+   */
+  extractSkillsFromText(text) {
+    // Common technology keywords
+    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'
+    ]
+
+    return techKeywords.filter(tech => 
+      text.toLowerCase().includes(tech.toLowerCase())
+    )
+  }
+
+  /**
+   * Calculate agent usefulness score
+   */
+  calculateUsefulness(agent) {
+    let score = 0
+
+    // Has skills
+    if (agent.skills && agent.skills.length > 0) {
+      score += 0.3
+      if (agent.skills.length > 3) {
+        score += 0.1 // Bonus for multiple skills
+      }
+    }
+
+    // Has specific domain
+    if (agent.domain && agent.domain !== 'general') {
+      score += 0.2
+    }
+
+    // Has content
+    if (agent.content && agent.content.length > 200) {
+      score += 0.2
+    }
+
+    // Has role
+    if (agent.role && agent.role.length > 10) {
+      score += 0.1
+    }
+
+    // Not generic name
+    if (agent.name && !agent.name.includes('generalist')) {
+      score += 0.1
+    }
+
+    return Math.min(score, 1.0)
+  }
+}
+
+module.exports = AgentValidator
+