prjct-cli 0.9.2 → 0.10.2

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
+