prjct-cli 0.9.2 → 0.10.2

package/core/commands.js

@@ -21,6 +21,7 @@ const path = require('path')
 const commandExecutor = require('./agentic/command-executor')
 const contextBuilder = require('./agentic/context-builder')
 const toolRegistry = require('./agentic/tool-registry')
+const memorySystem = require('./agentic/memory-system')
 const pathManager = require('./infrastructure/path-manager')
 const configManager = require('./infrastructure/config-manager')
 const authorDetector = require('./infrastructure/author-detector')
@@ -306,6 +307,7 @@ class PrjctCommands {
       const globalPath = pathManager.getGlobalProjectPath(projectId)
 
       // Create base files
+      // P1.1: Added patterns.json for Layered Memory System
       const baseFiles = {
         'core/now.md': '# NOW\n\nNo current task. Use `/p:now` to set focus.\n',
         'core/next.md': '# NEXT\n\n## Priority Queue\n\n',
@@ -314,7 +316,15 @@ class PrjctCommands {
         'progress/metrics.md': '# METRICS\n\n',
         'planning/ideas.md': '# IDEAS 💡\n\n## Brain Dump\n\n',
         'planning/roadmap.md': '# ROADMAP\n\n',
+        'planning/specs/.gitkeep': '# Specs directory - created by /p:spec\n',
         'memory/context.jsonl': '',
+        'memory/patterns.json': JSON.stringify({
+          version: 1,
+          decisions: {},
+          preferences: {},
+          workflows: {},
+          counters: {}
+        }, null, 2),
       }
 
       for (const [filePath, content] of Object.entries(baseFiles)) {
@@ -693,6 +703,27 @@ class PrjctCommands {
         timestamp: dateHelper.getTimestamp(),
       })
 
+      // P1.1: Learn patterns from this ship
+      const config = await configManager.getConfig(projectPath)
+      const projectId = config.projectId
+
+      // Record shipping workflow patterns
+      await memorySystem.learnDecision(projectId, 'commit_footer', 'prjct', 'ship')
+
+      // Track if tests were run (for quick_ship pattern learning)
+      if (testResult.success) {
+        await memorySystem.recordDecision(projectId, 'test_before_ship', 'true', 'ship')
+      }
+
+      // Record workflow if it's a quick ship (small changes)
+      const isQuickShip = !lintResult.success || !testResult.success
+      if (isQuickShip) {
+        await memorySystem.recordWorkflow(projectId, 'quick_ship', {
+          description: 'Ship without full checks',
+          feature_type: feature.toLowerCase().includes('doc') ? 'docs' : 'other'
+        })
+      }
+
       console.log('\n🎉 Feature shipped successfully!\n')
       console.log('💡 Recommendation: Compact conversation now')
       console.log('   (Keeps context clean for next feature)\n')
@@ -1133,7 +1164,6 @@ class PrjctCommands {
    */
   async _cleanupMemory(projectPath) {
     const projectId = await configManager.getProjectId(projectPath)
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
 
     console.log('📊 Analyzing disk usage...\n')
 
@@ -2317,8 +2347,14 @@ Agent: ${agent}
         gitCommits: analysisData.gitStats.totalCommits,
       })
 
+      // Generate dynamic context for Claude
+      const contextSync = require('./context-sync')
+      const projectId = await configManager.getProjectId(projectPath)
+      await contextSync.generateLocalContext(projectPath, projectId)
+
       console.log('✅ Analysis complete!\n')
-      console.log('📄 Full report: analysis/repo-summary.md\n')
+      console.log('📄 Full report: analysis/repo-summary.md')
+      console.log('📝 Context: ~/.prjct-cli/projects/' + projectId + '/CLAUDE.md\n')
       console.log('Next steps:')
       console.log('• /p:sync → Generate agents based on stack')
       console.log('• /p:feature → Add a new feature')
@@ -2474,7 +2510,7 @@ Agent: ${agent}
       const AgentGenerator = require('./domain/agent-generator')
       const generator = new AgentGenerator(projectId)
 
-      const generatedAgents = await this._generateAgentsFromAnalysis(summaryContent, generator)
+      const generatedAgents = await this._generateAgentsFromAnalysis(summaryContent, generator, projectPath)
 
       // Step 4: Log to memory
       await this.logToMemory(projectPath, 'agents_generated', {
@@ -2483,11 +2519,16 @@ Agent: ${agent}
         count: generatedAgents.length,
       })
 
+      // Generate dynamic context for Claude
+      const contextSync = require('./context-sync')
+      await contextSync.generateLocalContext(projectPath, projectId)
+
       console.log('\n✅ Sync complete!\n')
       console.log(`🤖 Agents Generated: ${generatedAgents.length}`)
       generatedAgents.forEach((agent) => {
         console.log(`   • ${agent}`)
       })
+      console.log('📝 Context: ~/.prjct-cli/projects/' + projectId + '/CLAUDE.md')
       console.log('\n📋 Based on: analysis/repo-summary.md')
       console.log('💡 See templates/agents/AGENTS.md for reference\n')
       console.log('Next steps:')
@@ -2506,91 +2547,118 @@ Agent: ${agent}
 
   /**
    * Generate agents dynamically from analysis summary
-   * Claude decides based on what technologies are detected
+   * 100% DYNAMIC - Uses TechDetector, NO HARDCODING
+   * Claude decides based on actual detected technologies
    * @private
    */
-  async _generateAgentsFromAnalysis(summaryContent, generator) {
+  async _generateAgentsFromAnalysis(summaryContent, generator, projectPath) {
     const agents = []
+    const TechDetector = require('./domain/tech-detector')
+    const detector = new TechDetector(projectPath)
+    const tech = await detector.detectAll()
 
-    // Parse summary to identify technologies
-    // Simple detection based on sections (NOT predetermined patterns)
-
-    // Detect languages/frameworks from summary
-    const hasJavaScript =
-      summaryContent.includes('JavaScript') || summaryContent.includes('TypeScript')
-    const hasNextJS = summaryContent.includes('Next.js')
-    const hasVite = summaryContent.includes('Vite')
-    const hasReact = summaryContent.includes('react')
-    const hasRust = summaryContent.includes('Rust')
-    const hasGo = summaryContent.includes('Go')
-    const hasPython = summaryContent.includes('Python')
-    const hasDocker = summaryContent.includes('Docker')
+    // Generate agents based on ACTUAL detected technologies
+    // No assumptions, no hardcoding - just what we found
 
-    // Generate agents based on detected stack
-    // Each agent is specific to THIS project's stack
+    // Frontend agents - if we have frontend frameworks
+    const frontendFrameworks = tech.frameworks.filter(f => 
+      ['react', 'vue', 'angular', 'svelte', 'next', 'nuxt', 'sveltekit', 'remix'].includes(f.toLowerCase())
+    )
+    const frontendBuildTools = tech.buildTools.filter(t => 
+      ['vite', 'webpack', 'rollup', 'esbuild'].includes(t.toLowerCase())
+    )
 
-    if (hasJavaScript || hasNextJS || hasVite) {
+    if (frontendFrameworks.length > 0 || frontendBuildTools.length > 0 || tech.languages.includes('JavaScript') || tech.languages.includes('TypeScript')) {
+      const frameworkList = frontendFrameworks.length > 0 
+        ? frontendFrameworks.join(', ')
+        : (frontendBuildTools.length > 0 ? frontendBuildTools.join(', ') : 'JavaScript/TypeScript')
+      
       await generator.generateDynamicAgent('frontend-specialist', {
         role: 'Frontend Development Specialist',
-        expertise: `${hasNextJS ? 'Next.js' : hasVite ? 'Vite' : 'JavaScript/TypeScript'}, ${hasReact ? 'React' : 'Modern JavaScript frameworks'}`,
-        responsibilities:
-          'Handle UI components, state management, routing, and frontend architecture',
+        expertise: `${frameworkList}, ${tech.languages.filter(l => ['JavaScript', 'TypeScript'].includes(l)).join(' or ') || 'Modern JavaScript'}`,
+        responsibilities: 'Handle UI components, state management, routing, and frontend architecture',
         projectContext: {
-          detectedFramework: hasNextJS ? 'Next.js' : hasVite ? 'Vite + React' : 'JavaScript',
+          detectedFrameworks: frontendFrameworks,
+          buildTools: frontendBuildTools,
+          languages: tech.languages.filter(l => ['JavaScript', 'TypeScript'].includes(l))
         },
       })
       agents.push('frontend-specialist')
     }
 
-    if (hasRust) {
-      await generator.generateDynamicAgent('rust-developer', {
-        role: 'Rust Development Specialist',
-        expertise: 'Rust, Cargo, performance optimization, memory safety',
-        responsibilities:
-          'Handle Rust codebase, performance-critical components, systems programming',
-        projectContext: { language: 'Rust' },
-      })
-      agents.push('rust-developer')
-    }
+    // Backend agents - if we have backend frameworks or languages
+    const backendFrameworks = tech.frameworks.filter(f => 
+      ['express', 'fastify', 'koa', 'hapi', 'nest', 'django', 'flask', 'fastapi', 'rails', 'phoenix', 'laravel'].includes(f.toLowerCase())
+    )
+    const backendLanguages = tech.languages.filter(l => 
+      ['Go', 'Rust', 'Python', 'Ruby', 'Elixir', 'Java', 'PHP'].includes(l)
+    )
 
-    if (hasGo) {
-      await generator.generateDynamicAgent('go-developer', {
-        role: 'Go Development Specialist',
-        expertise: 'Go, Go modules, concurrency, backend services',
-        responsibilities: 'Handle Go codebase, backend services, API development',
-        projectContext: { language: 'Go' },
+    if (backendFrameworks.length > 0 || backendLanguages.length > 0) {
+      const agentName = backendLanguages.length > 0 
+        ? `${backendLanguages[0].toLowerCase()}-developer`
+        : 'backend-specialist'
+      
+      const expertise = backendFrameworks.length > 0
+        ? backendFrameworks.join(', ')
+        : backendLanguages.join(', ')
+
+      await generator.generateDynamicAgent(agentName, {
+        role: `${backendLanguages[0] || 'Backend'} Development Specialist`,
+        expertise,
+        responsibilities: 'Handle backend services, API development, server logic',
+        projectContext: {
+          detectedFrameworks: backendFrameworks,
+          languages: backendLanguages
+        },
       })
-      agents.push('go-developer')
+      agents.push(agentName)
     }
 
-    if (hasPython) {
-      await generator.generateDynamicAgent('python-developer', {
-        role: 'Python Development Specialist',
-        expertise: 'Python, pip, Django/Flask, data processing',
-        responsibilities: 'Handle Python codebase, backend logic, data processing',
-        projectContext: { language: 'Python' },
+    // Database specialist - if we have database tools
+    if (tech.databases.length > 0) {
+      await generator.generateDynamicAgent('database-specialist', {
+        role: 'Database Specialist',
+        expertise: tech.databases.join(', '),
+        responsibilities: 'Handle database design, queries, migrations, data modeling',
+        projectContext: {
+          databases: tech.databases
+        },
       })
-      agents.push('python-developer')
+      agents.push('database-specialist')
     }
 
-    if (hasDocker) {
+    // DevOps specialist - if we have DevOps tools
+    if (tech.tools.some(t => ['Docker', 'Kubernetes', 'Terraform'].includes(t))) {
       await generator.generateDynamicAgent('devops-specialist', {
         role: 'DevOps & Infrastructure Specialist',
-        expertise: 'Docker, Docker Compose, containerization, deployment',
+        expertise: tech.tools.filter(t => ['Docker', 'Kubernetes', 'Terraform'].includes(t)).join(', '),
         responsibilities: 'Handle containerization, deployment, infrastructure setup',
-        projectContext: { hasDocker: true },
+        projectContext: {
+          tools: tech.tools
+        },
       })
       agents.push('devops-specialist')
     }
 
-    // Always generate a QA specialist if we have code
-    await generator.generateDynamicAgent('qa-specialist', {
-      role: 'Quality Assurance Specialist',
-      expertise: 'Testing frameworks, test automation, quality metrics',
-      responsibilities: 'Handle testing strategy, test creation, quality assurance',
-      projectContext: { role: 'QA' },
-    })
-    agents.push('qa-specialist')
+    // QA specialist - always generate if we have test frameworks or any code
+    if (tech.testFrameworks.length > 0 || tech.languages.length > 0) {
+      const testExpertise = tech.testFrameworks.length > 0
+        ? tech.testFrameworks.join(', ')
+        : 'Testing frameworks, test automation'
+
+      await generator.generateDynamicAgent('qa-specialist', {
+        role: 'Quality Assurance Specialist',
+        expertise: testExpertise,
+        responsibilities: 'Handle testing strategy, test creation, quality assurance',
+        projectContext: {
+          testFrameworks: tech.testFrameworks,
+          languages: tech.languages,
+          role: 'QA'
+        },
+      })
+      agents.push('qa-specialist')
+    }
 
     return agents
   }

package/core/context-sync.js

@@ -0,0 +1,183 @@
+/**
+ * Context Sync - Generates dynamic project context for Claude
+ *
+ * Creates ~/.prjct-cli/projects/{id}/CLAUDE.md with:
+ * - Stack info
+ * - Available agents (dynamic, varies per project)
+ * - Current task
+ * - Priority queue
+ *
+ * Called by: /p:sync, /p:analyze, /p:init
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const os = require('os')
+
+/**
+ * Generate project context file for Claude
+ * 100% DYNAMIC - reads whatever agents exist
+ *
+ * @param {string} projectPath - Local project path
+ * @param {string} projectId - Project ID from config
+ * @returns {Promise<{agents: string[], stack: string|null, currentTask: string|null}>}
+ */
+async function generateLocalContext(projectPath, projectId) {
+  const globalPath = path.join(os.homedir(), '.prjct-cli/projects', projectId)
+
+  // 1. Read ALL agents that exist (dynamic - varies per project)
+  const agentsDir = path.join(globalPath, 'agents')
+  let agentFiles = []
+  try {
+    agentFiles = await fs.readdir(agentsDir)
+    agentFiles = agentFiles.filter(f => f.endsWith('.md'))
+  } catch {
+    // No agents directory yet
+  }
+
+  // 2. Read core files (may not exist)
+  const readSafe = async (p) => {
+    try {
+      return await fs.readFile(p, 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  const [repoSummary, now, next, roadmap] = await Promise.all([
+    readSafe(path.join(globalPath, 'analysis/repo-summary.md')),
+    readSafe(path.join(globalPath, 'core/now.md')),
+    readSafe(path.join(globalPath, 'core/next.md')),
+    readSafe(path.join(globalPath, 'planning/roadmap.md'))
+  ])
+
+  // 3. Extract stack from repo-summary
+  const stack = extractStack(repoSummary)
+
+  // 4. Generate agent list with clean names
+  const agents = agentFiles.map(f => f.replace('.md', ''))
+
+  // 5. Extract current task
+  const currentTask = extractCurrentTask(now)
+
+  // 6. Extract top 3 from next.md
+  const nextTasks = extractTopTasks(next, 3)
+
+  // 7. Extract active features from roadmap
+  const activeFeatures = extractActiveFeatures(roadmap)
+
+  // 8. Generate CLAUDE.md content
+  const content = `# Project Context
+<!-- Auto-generated by /p:sync - DO NOT EDIT -->
+<!-- projectId: ${projectId} -->
+<!-- Last sync: ${new Date().toISOString()} -->
+
+## Stack
+${stack || 'Run /p:analyze to detect stack'}
+
+## Available Agents
+${agents.length ? agents.map(a => `- ${a}`).join('\n') : 'None. Run /p:sync to generate.'}
+
+## Current Task
+${currentTask || 'None. Use /p:now to start.'}
+
+## Next Up
+${nextTasks.length ? nextTasks.map((t, i) => `${i + 1}. ${t}`).join('\n') : 'Empty queue.'}
+
+## Active Features
+${activeFeatures.length ? activeFeatures.map(f => `- ${f}`).join('\n') : 'None in progress.'}
+
+## Data Location
+All project data: ~/.prjct-cli/projects/${projectId}/
+- agents/ - Read for detailed patterns and code examples
+- analysis/repo-summary.md - Full technical analysis
+- planning/roadmap.md - Features and roadmap
+`
+
+  // 9. Write to global storage (NOT in repo)
+  const contextPath = path.join(globalPath, 'CLAUDE.md')
+  await fs.writeFile(contextPath, content, 'utf-8')
+
+  return { agents, stack, currentTask }
+}
+
+/**
+ * Extract stack from repo-summary
+ */
+function extractStack(summary) {
+  if (!summary) return null
+
+  // Try multiple patterns
+  const patterns = [
+    /\*\*(?:Stack|Framework|Language)\*\*[:\s|]+([^\n|]+)/i,
+    /\| \*\*Type\*\* \| ([^\|]+) \|/i,
+    /## Tech Stack[\s\S]*?### (?:Frontend|Backend)\n- \*\*([^*]+)\*\*/i
+  ]
+
+  for (const pattern of patterns) {
+    const match = summary.match(pattern)
+    if (match) return match[1].trim()
+  }
+
+  return null
+}
+
+/**
+ * Extract current task from now.md
+ */
+function extractCurrentTask(now) {
+  if (!now) return null
+
+  // Skip headers and empty lines, get first content line
+  const lines = now.split('\n')
+  for (const line of lines) {
+    const trimmed = line.trim()
+    if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('<!--')) {
+      return trimmed
+    }
+  }
+  return null
+}
+
+/**
+ * Extract top N tasks from next.md
+ */
+function extractTopTasks(next, count) {
+  if (!next) return []
+
+  return next
+    .split('\n')
+    .filter(l => l.match(/^[-*\d.]\s/))
+    .slice(0, count)
+    .map(l => l.replace(/^[-*\d.]\s+/, '').trim())
+    .filter(Boolean)
+}
+
+/**
+ * Extract active features from roadmap.md
+ */
+function extractActiveFeatures(roadmap) {
+  if (!roadmap) return []
+
+  const features = []
+  const lines = roadmap.split('\n')
+  let inActive = false
+
+  for (const line of lines) {
+    if (line.includes('Active') || line.includes('In Progress')) {
+      inActive = true
+      continue
+    }
+    if (line.startsWith('## ') && inActive) {
+      break // End of active section
+    }
+    if (inActive && line.match(/^- \[ \]/)) {
+      const feature = line.replace(/^- \[ \]\s*\*\*/, '').replace(/\*\*.*$/, '').trim()
+      if (feature) features.push(feature)
+    }
+  }
+
+  return features.slice(0, 3) // Max 3
+}
+
+module.exports = { generateLocalContext }

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