prjct-cli 0.9.2 → 0.10.0

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
+

package/core/domain/context-estimator.js

@@ -0,0 +1,175 @@
+/**
+ * ContextEstimator - Pre-filter files before building context
+ * 
+ * Estimates which files are needed based on task analysis
+ * BEFORE building full context - saves I/O
+ * 
+ * @version 1.0.0
+ */
+
+const path = require('path')
+const { glob } = require('glob')
+
+class ContextEstimator {
+  /**
+   * Estimate which files are needed for a task
+   * @param {Object} taskAnalysis - Task analysis result
+   * @param {string} projectPath - Project path
+   * @returns {Promise<Array<string>>} Estimated file paths
+   */
+  async estimateFiles(taskAnalysis, projectPath) {
+    const domain = taskAnalysis.primaryDomain
+    const projectTech = taskAnalysis.projectTechnologies || {}
+    const semantic = taskAnalysis.semantic || {}
+
+    // Get patterns for this domain
+    const patterns = this.getPatternsForDomain(domain, projectTech)
+
+    // Expand with semantic understanding
+    if (semantic.requiresMultipleAgents && semantic.agents) {
+      // Multi-agent task - combine patterns
+      const allPatterns = semantic.agents.reduce((acc, agentDomain) => {
+        const agentPatterns = this.getPatternsForDomain(agentDomain, projectTech)
+        return {
+          include: [...acc.include, ...agentPatterns.include],
+          extensions: [...acc.extensions, ...agentPatterns.extensions]
+        }
+      }, { include: [], extensions: [] })
+
+      patterns.include = [...new Set(allPatterns.include)]
+      patterns.extensions = [...new Set(allPatterns.extensions)]
+    }
+
+    // Find files matching patterns
+    const files = await this.findMatchingFiles(projectPath, patterns)
+
+    // Limit to reasonable number
+    const maxFiles = 200
+    return files.slice(0, maxFiles)
+  }
+
+  /**
+   * Get file patterns for a domain
+   */
+  getPatternsForDomain(domain, projectTech) {
+    const patterns = {
+      include: [],
+      extensions: [],
+      exclude: ['node_modules', 'dist', 'build', '.git']
+    }
+
+    switch (domain) {
+      case 'frontend':
+        patterns.include = ['src', 'components', 'pages', 'views', 'app']
+        patterns.extensions = ['.tsx', '.jsx', '.vue', '.svelte', '.css', '.scss', '.styled.js']
+        
+        // Add framework-specific patterns
+        if (projectTech.frameworks) {
+          if (projectTech.frameworks.some(f => f.toLowerCase().includes('next'))) {
+            patterns.include.push('pages', 'app', 'components')
+          }
+          if (projectTech.frameworks.some(f => f.toLowerCase().includes('react'))) {
+            patterns.extensions.push('.tsx', '.jsx')
+          }
+        }
+        break
+
+      case 'backend':
+        patterns.include = ['src', 'lib', 'api', 'routes', 'controllers', 'services', 'app']
+        patterns.extensions = ['.js', '.ts', '.py', '.rb', '.go', '.rs']
+        
+        // Framework-specific
+        if (projectTech.frameworks) {
+          if (projectTech.frameworks.some(f => f.toLowerCase().includes('express'))) {
+            patterns.include.push('routes', 'middleware', 'controllers')
+          }
+          if (projectTech.frameworks.some(f => f.toLowerCase().includes('django'))) {
+            patterns.include.push('views', 'urls', 'models')
+          }
+        }
+        break
+
+      case 'database':
+        patterns.include = ['migrations', 'models', 'schemas', 'db', 'database']
+        patterns.extensions = ['.sql', '.js', '.ts', '.rb', '.py']
+        break
+
+      case 'qa':
+        patterns.include = ['tests', '__tests__', 'spec', 'test']
+        patterns.extensions = ['.test.js', '.test.ts', '.spec.js', '.spec.ts']
+        break
+
+      case 'devops':
+        patterns.include = ['.github', '.gitlab', 'docker', 'k8s', 'kubernetes', 'terraform']
+        patterns.extensions = ['.yml', '.yaml', '.dockerfile', '.sh', '.tf']
+        break
+
+      default:
+        // General - include common source directories
+        patterns.include = ['src', 'lib', 'app']
+        patterns.extensions = ['.js', '.ts', '.jsx', '.tsx', '.py', '.rb']
+    }
+
+    return patterns
+  }
+
+  /**
+   * Find files matching patterns
+   */
+  async findMatchingFiles(projectPath, patterns) {
+    const files = []
+
+    try {
+      // Build glob patterns
+      const globPatterns = []
+
+      // Add include patterns
+      for (const include of patterns.include) {
+        for (const ext of patterns.extensions) {
+          globPatterns.push(`${include}/**/*${ext}`)
+          globPatterns.push(`**/${include}/**/*${ext}`)
+        }
+      }
+
+      // Also search root level
+      for (const ext of patterns.extensions) {
+        globPatterns.push(`*${ext}`)
+      }
+
+      // Execute glob searches
+      for (const pattern of globPatterns) {
+        try {
+          const matches = await glob(pattern, {
+            cwd: projectPath,
+            ignore: patterns.exclude.map(ex => `**/${ex}/**`),
+            nodir: true,
+            follow: false
+          })
+
+          if (Array.isArray(matches)) {
+            files.push(...matches)
+          }
+        } catch (error) {
+          // Skip invalid patterns
+        }
+      }
+
+      // Remove duplicates and sort
+      return [...new Set(files)].sort()
+    } catch (error) {
+      console.error('Error finding files:', error.message)
+      return []
+    }
+  }
+
+  /**
+   * Estimate context size (number of files)
+   */
+  async estimateContextSize(taskAnalysis, projectPath) {
+    const files = await this.estimateFiles(taskAnalysis, projectPath)
+    return files.length
+  }
+}
+
+module.exports = ContextEstimator
+

package/core/domain/product-standards.js

@@ -0,0 +1,92 @@
+/**
+ * Modern Product Standards
+ * Defines what "Good" looks like for each domain.
+ * Used to inject high standards into agent prompts.
+ */
+
+const ProductStandards = {
+  // General standards applicable to all agents
+  general: [
+    'SHIP IT: Bias for action. Better to ship and iterate than perfect and delay.',
+    'USER CENTRIC: Always ask "How does this help the user?"',
+    'CLEAN CODE: Write code that is easy to read, test, and maintain.',
+    'NO BS: Avoid over-engineering. Simple is better than complex.'
+  ],
+
+  // Domain-specific standards
+  domains: {
+    frontend: {
+      title: 'Modern Frontend Standards',
+      rules: [
+        'PERFORMANCE: Core Web Vitals matter. Optimize LCP, CLS, FID.',
+        'ACCESSIBILITY: Semantic HTML, ARIA labels, keyboard navigation (WCAG 2.1 AA).',
+        'RESPONSIVE: Mobile-first design. Works on all devices.',
+        'UX/UI: Smooth transitions, loading states, error boundaries. No dead clicks.',
+        'STATE: Local state for UI, Global state (Context/Zustand) for data. No prop drilling.'
+      ]
+    },
+    backend: {
+      title: 'Robust Backend Standards',
+      rules: [
+        'SECURITY: Validate ALL inputs. Sanitize outputs. OWASP Top 10 awareness.',
+        'SCALABILITY: Stateless services. Caching strategies (Redis/CDN).',
+        'RELIABILITY: Graceful error handling. Structured logging. Health checks.',
+        'API DESIGN: RESTful or GraphQL best practices. Consistent response envelopes.',
+        'DB: Indexed queries. Migrations for schema changes. No N+1 queries.'
+      ]
+    },
+    database: {
+      title: 'Data Integrity Standards',
+      rules: [
+        'INTEGRITY: Foreign keys, constraints, transactions.',
+        'PERFORMANCE: Index usage analysis. Query optimization.',
+        'BACKUPS: Point-in-time recovery awareness.',
+        'MIGRATIONS: Idempotent scripts. Zero-downtime changes.'
+      ]
+    },
+    devops: {
+      title: 'Modern Ops Standards',
+      rules: [
+        'AUTOMATION: CI/CD for everything. No manual deployments.',
+        'IaC: Infrastructure as Code (Terraform/Pulumi).',
+        'OBSERVABILITY: Metrics, Logs, Traces (OpenTelemetry).',
+        'SECURITY: Least privilege access. Secrets management.'
+      ]
+    },
+    qa: {
+      title: 'Quality Assurance Standards',
+      rules: [
+        'PYRAMID: Many unit tests, some integration, few E2E.',
+        'COVERAGE: Critical paths must be tested.',
+        'REALISM: Test with realistic data and scenarios.',
+        'SPEED: Fast feedback loops. Parallel execution.'
+      ]
+    },
+    architecture: {
+      title: 'System Architecture Standards',
+      rules: [
+        'MODULARITY: High cohesion, low coupling.',
+        'EVOLVABILITY: Easy to change. Hard to break.',
+        'SIMPLICITY: Choose boring technology. Innovation tokens are limited.',
+        'DOCS: Architecture Decision Records (ADRs).'
+      ]
+    }
+  },
+
+  /**
+   * Get standards for a specific domain
+   * @param {string} domain - The domain (frontend, backend, etc.)
+   * @returns {Object} The standards object
+   */
+  getStandards(domain) {
+    const key = domain?.toLowerCase();
+    const specific = this.domains[key] || { title: 'General Standards', rules: [] };
+    
+    return {
+      title: specific.title,
+      rules: [...this.general, ...specific.rules]
+    };
+  }
+};
+
+module.exports = ProductStandards;

package/core/domain/smart-cache.js

@@ -0,0 +1,157 @@
+/**
+ * SmartCache - Intelligent Persistent Cache for Agents
+ * 
+ * Cache with specific keys: {projectId}-{domain}-{techStack}
+ * Persists to disk for cross-session caching
+ * Invalidates only when stack changes
+ * 
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+const crypto = require('crypto')
+
+class SmartCache {
+  constructor(projectId = null) {
+    this.projectId = projectId
+    this.memoryCache = new Map()
+    this.cacheDir = path.join(os.homedir(), '.prjct-cli', 'cache')
+    this.cacheFile = projectId
+      ? path.join(this.cacheDir, `agents-${projectId}.json`)
+      : path.join(this.cacheDir, 'agents-global.json')
+  }
+
+  /**
+   * Initialize cache - load from disk
+   */
+  async initialize() {
+    try {
+      await fs.mkdir(this.cacheDir, { recursive: true })
+      await this.loadFromDisk()
+    } catch (error) {
+      // Cache file doesn't exist yet - that's ok
+      this.memoryCache = new Map()
+    }
+  }
+
+  /**
+   * Generate cache key
+   * Format: {projectId}-{domain}-{techStackHash}
+   */
+  generateKey(projectId, domain, techStack = {}) {
+    const techString = JSON.stringify(techStack)
+    const techHash = crypto.createHash('md5').update(techString).digest('hex').substring(0, 8)
+    return `${projectId || 'global'}-${domain}-${techHash}`
+  }
+
+  /**
+   * Get from cache
+   */
+  async get(key) {
+    // Check memory first
+    if (this.memoryCache.has(key)) {
+      return this.memoryCache.get(key)
+    }
+
+    // Load from disk if not in memory
+    await this.loadFromDisk()
+    return this.memoryCache.get(key) || null
+  }
+
+  /**
+   * Set in cache
+   */
+  async set(key, value) {
+    // Set in memory
+    this.memoryCache.set(key, value)
+
+    // Persist to disk (async, don't wait)
+    this.persistToDisk().catch(err => {
+      console.error('Cache persist error:', err.message)
+    })
+  }
+
+  /**
+   * Check if key exists
+   */
+  async has(key) {
+    if (this.memoryCache.has(key)) {
+      return true
+    }
+
+    await this.loadFromDisk()
+    return this.memoryCache.has(key)
+  }
+
+  /**
+   * Clear cache
+   */
+  async clear() {
+    this.memoryCache.clear()
+    try {
+      await fs.unlink(this.cacheFile)
+    } catch {
+      // File doesn't exist - that's ok
+    }
+  }
+
+  /**
+   * Invalidate cache for a project (when stack changes)
+   */
+  async invalidateProject(projectId) {
+    const keysToDelete = []
+    for (const key of this.memoryCache.keys()) {
+      if (key.startsWith(`${projectId}-`)) {
+        keysToDelete.push(key)
+      }
+    }
+
+    keysToDelete.forEach(key => this.memoryCache.delete(key))
+    await this.persistToDisk()
+  }
+
+  /**
+   * Load cache from disk
+   */
+  async loadFromDisk() {
+    try {
+      const content = await fs.readFile(this.cacheFile, 'utf-8')
+      const data = JSON.parse(content)
+      
+      // Restore to memory cache
+      for (const [key, value] of Object.entries(data)) {
+        this.memoryCache.set(key, value)
+      }
+    } catch {
+      // File doesn't exist or invalid - start fresh
+      this.memoryCache = new Map()
+    }
+  }
+
+  /**
+   * Persist cache to disk
+   */
+  async persistToDisk() {
+    try {
+      const data = Object.fromEntries(this.memoryCache)
+      await fs.writeFile(this.cacheFile, JSON.stringify(data, null, 2), 'utf-8')
+    } catch (error) {
+      // Fail silently - cache is best effort
+    }
+  }
+
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    return {
+      size: this.memoryCache.size,
+      keys: Array.from(this.memoryCache.keys())
+    }
+  }
+}
+
+module.exports = SmartCache
+