prjct-cli 0.10.8 → 0.10.10

package/core/agentic/context-builder.js

@@ -67,6 +67,7 @@ class ContextBuilder {
         memory: pathManager.getFilePath(projectId, 'memory', 'context.jsonl'),
         patterns: pathManager.getFilePath(projectId, 'memory', 'patterns.json'),
         analysis: pathManager.getFilePath(projectId, 'analysis', 'repo-summary.md'),
+        codePatterns: pathManager.getFilePath(projectId, 'analysis', 'patterns.md'),
       },
 
       // Command parameters
@@ -168,10 +169,10 @@ class ContextBuilder {
   async loadStateForCommand(context, commandName) {
     // Command-specific file requirements
     // Minimizes context window usage
-    // CRITICAL: Always include 'analysis' for pattern detection
+    // CRITICAL: Include 'codePatterns' for ALL code-modifying commands
     const commandFileMap = {
       // Core workflow
-      'now': ['now', 'next', 'analysis'],
+      'now': ['now', 'next', 'analysis', 'codePatterns'],
       'done': ['now', 'next', 'metrics', 'analysis'],
       'next': ['next', 'analysis'],
 
@@ -182,24 +183,24 @@ class ContextBuilder {
 
       // Planning
       'idea': ['ideas', 'next', 'analysis'],
-      'feature': ['roadmap', 'next', 'ideas', 'analysis'],
+      'feature': ['roadmap', 'next', 'ideas', 'analysis', 'codePatterns'],
       'roadmap': ['roadmap', 'analysis'],
-      'spec': ['roadmap', 'next', 'specs', 'analysis'],
+      'spec': ['roadmap', 'next', 'specs', 'analysis', 'codePatterns'],
 
       // Analysis
-      'analyze': ['analysis', 'context'],
-      'sync': ['analysis', 'context', 'now'],
-
-      // Code modification commands - ALWAYS need analysis for patterns
-      'work': ['now', 'next', 'analysis', 'context'],
-      'build': ['now', 'next', 'analysis', 'context'],
-      'design': ['analysis', 'context'],
-      'cleanup': ['analysis', 'context'],
-      'fix': ['analysis', 'context'],
-      'test': ['analysis', 'context'],
-
-      // All files (fallback)
-      'default': ['analysis'] // Always include analysis even for unknown commands
+      'analyze': ['analysis', 'context', 'codePatterns'],
+      'sync': ['analysis', 'context', 'now', 'codePatterns'],
+
+      // Code modification commands - ALWAYS need codePatterns
+      'work': ['now', 'next', 'analysis', 'context', 'codePatterns'],
+      'build': ['now', 'next', 'analysis', 'context', 'codePatterns'],
+      'design': ['analysis', 'context', 'codePatterns'],
+      'cleanup': ['analysis', 'context', 'codePatterns'],
+      'fix': ['analysis', 'context', 'codePatterns'],
+      'test': ['analysis', 'context', 'codePatterns'],
+
+      // All files (fallback) - include codePatterns for any code work
+      'default': ['analysis', 'codePatterns']
     }
 
     const requiredFiles = commandFileMap[commandName] || commandFileMap.default

package/core/agentic/prompt-builder.js

@@ -24,41 +24,18 @@ class PromptBuilder {
     // Store context for use in helper methods
     this._currentContext = context
 
-    // Agent assignment (if applicable)
-    // CRITICAL: Include full agent content, not just name
-    if (agent) {
-      parts.push(`# AGENT ASSIGNMENT\n`)
-      parts.push(`Agent: ${agent.name}\n`)
-      
-      // Include role if available
-      if (agent.role) {
-        parts.push(`Role: ${agent.role}\n`)
-      }
-      
-      // Include domain if available
-      if (agent.domain) {
-        parts.push(`Domain: ${agent.domain}\n`)
-      }
-      
-      // Include skills if available
-      if (agent.skills && agent.skills.length > 0) {
-        parts.push(`Skills: ${agent.skills.join(', ')}\n`)
-      }
-      
-      parts.push(`\n## AGENT INSTRUCTIONS\n`)
-      
-      // CRITICAL: Include full agent content
-      // This is the specialized knowledge for this project
-      if (agent.content) {
-        parts.push(agent.content)
-        parts.push(`\n`)
-      } else if (agent.name) {
-        // Fallback if content not loaded
-        parts.push(`You are the ${agent.name} agent for this project.\n`)
-        parts.push(`Apply your specialized expertise to complete the task.\n\n`)
-      }
-      
-      parts.push(`CONTEXT: ${context.filteredSize || 'all'} files (${context.reduction || 0}% reduced)\n\n`)
+    // Agent assignment (CONDITIONAL - only for code-modifying commands)
+    // Commands like done, ship, recap, next don't need specialized agents
+    const commandName = template.frontmatter?.name?.replace('p:', '') || ''
+    const agentCommands = ['now', 'build', 'feature', 'design', 'fix', 'bug', 'test', 'work', 'cleanup', 'spec']
+    const needsAgent = agentCommands.includes(commandName)
+
+    if (agent && needsAgent) {
+      // COMPRESSED: Only essential agent info (500 bytes vs 3-5KB)
+      parts.push(`# AGENT: ${agent.name}\n`)
+      if (agent.role) parts.push(`Role: ${agent.role}\n`)
+      if (agent.skills?.length) parts.push(`Skills: ${agent.skills.join(', ')}\n`)
+      parts.push(`\nApply specialized expertise. Read agent file for details if needed.\n\n`)
     }
 
     // Core instruction (concise)
@@ -93,31 +70,32 @@ class PromptBuilder {
       parts.push('\n')
     }
 
-    // CRITICAL: Include available project files for context
-    if (context.files && context.files.length > 0) {
-      parts.push('\n## AVAILABLE PROJECT FILES\n')
-      parts.push(`You have ${context.files.length} relevant files available in this project.\n`)
-      parts.push('**USE Read TOOL TO LOAD FILES BEFORE MODIFYING THEM.**\n')
-      parts.push('\nTop relevant files:\n')
-      const topFiles = context.files.slice(0, 20).map(f => `- ${f}`).join('\n')
-      parts.push(topFiles)
-      if (context.files.length > 20) {
-        parts.push(`\n... and ${context.files.length - 20} more files. Use Read tool to access them.\n`)
-      }
-      parts.push('\n')
+    // COMPRESSED: File list (5 files vs 20, saves ~400 bytes)
+    if (context.files?.length > 0) {
+      const top5 = context.files.slice(0, 5).join(', ')
+      parts.push(`\n## FILES: ${context.files.length} available. Top: ${top5}\n`)
+      parts.push('Read BEFORE modifying. Use Glob/Grep to find more.\n\n')
     } else if (context.projectPath) {
-      parts.push('\n## PROJECT FILES\n')
-      parts.push(`Project path: ${context.projectPath}\n`)
-      parts.push('**USE Read TOOL TO LOAD FILES YOU NEED TO UNDERSTAND OR MODIFY.**\n')
-      parts.push('**NEVER MODIFY CODE WITHOUT READING IT FIRST.**\n\n')
+      parts.push(`\n## PROJECT: ${context.projectPath}\nRead files before modifying.\n\n`)
     }
 
     // OPTIMIZED: Only include patterns for code-modifying commands
-    // Commands like now, done, ship, recap, next don't need full patterns
-    const codeCommands = ['build', 'feature', 'design', 'cleanup', 'fix', 'bug', 'test', 'init']
-    const commandName = template.frontmatter?.name?.replace('p:', '') || ''
+    // Commands like done, ship, recap, next don't need full patterns
+    const codeCommands = ['now', 'build', 'feature', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec', 'work']
     const needsPatterns = codeCommands.includes(commandName)
 
+    // Include code patterns analysis for code-modifying commands
+    // COMPRESSED: Extract only conventions and anti-patterns (800 bytes max vs 6KB)
+    const codePatternsContent = state?.codePatterns || ''
+    if (needsPatterns && codePatternsContent && codePatternsContent.trim()) {
+      const patternSummary = this.extractPatternSummary(codePatternsContent)
+      if (patternSummary) {
+        parts.push('\n## CODE PATTERNS\n')
+        parts.push(patternSummary)
+        parts.push('\nFull patterns: Read analysis/patterns.md\n')
+      }
+    }
+
     const analysisContent = state?.analysis || ''
     if (needsPatterns && analysisContent && analysisContent.trim()) {
       // Extract stack info compactly
@@ -125,8 +103,10 @@ class PromptBuilder {
                         analysisContent.match(/Technology[:\s]+([^\n]+)/i)
       const stack = stackMatch ? stackMatch[1].trim() : 'detected'
 
-      parts.push(`\n## PATTERNS\nStack: ${stack}\n`)
-      parts.push('Read analysis/repo-summary.md + similar files before coding. Match patterns exactly.\n')
+      parts.push(`\n## STACK\nStack: ${stack}\n`)
+      if (!codePatternsContent) {
+        parts.push('Read analysis/repo-summary.md + similar files before coding. Match patterns exactly.\n')
+      }
     }
 
     // CRITICAL: Compressed rules (replaces 78 lines with 12)
@@ -190,8 +170,8 @@ class PromptBuilder {
     const relevant = []
     for (const [key, content] of Object.entries(state)) {
       if (content && content.trim()) {
-        // Include full content for critical files (now, next, context)
-        const criticalFiles = ['now', 'next', 'context', 'analysis']
+        // Include full content for critical files (now, next, context, patterns)
+        const criticalFiles = ['now', 'next', 'context', 'analysis', 'codePatterns']
         if (criticalFiles.includes(key)) {
           // Include full content for critical files (up to 2000 chars)
           const display = content.length > 2000 
@@ -232,6 +212,38 @@ class PromptBuilder {
     return parts.join('')
   }
 
+  /**
+   * Extract pattern summary from full patterns content
+   * OPTIMIZED: Returns only conventions + high-priority anti-patterns (800 bytes max)
+   */
+  extractPatternSummary(content) {
+    if (!content) return null
+
+    const parts = []
+
+    // Extract conventions section
+    const conventionsMatch = content.match(/## Conventions[\s\S]*?(?=##|$)/i)
+    if (conventionsMatch) {
+      // Compress to key lines only
+      const conventions = conventionsMatch[0]
+        .split('\n')
+        .filter(line => line.includes(':') || line.startsWith('-'))
+        .slice(0, 6)
+        .join('\n')
+      if (conventions) parts.push(conventions)
+    }
+
+    // Extract high priority anti-patterns only
+    const antiPatternsMatch = content.match(/### High Priority[\s\S]*?(?=###|##|$)/i)
+    if (antiPatternsMatch) {
+      const antiPatterns = antiPatternsMatch[0].substring(0, 300)
+      parts.push('\nAvoid:\n' + antiPatterns)
+    }
+
+    const result = parts.join('\n').substring(0, 800)
+    return result || null
+  }
+
   /**
    * Build critical rules - compressed anti-hallucination
    * OPTIMIZED: From 66 lines to 12 lines (~82% reduction)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.10.8",
+  "version": "0.10.10",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {

package/templates/analysis/patterns.md

@@ -0,0 +1,60 @@
+---
+allowed-tools: [Read, Glob, Grep]
+description: 'Analyze code patterns and conventions'
+---
+
+# Code Pattern Analysis
+
+## Detection Steps
+
+1. **Structure** (5-10 files): File org, exports, modules
+2. **Patterns**: SOLID, DRY, factory/singleton/observer
+3. **Conventions**: Naming, style, error handling, async
+4. **Anti-patterns**: God class, spaghetti, copy-paste, magic numbers
+5. **Performance**: Memoization, N+1 queries, leaks
+
+## Output: analysis/patterns.md
+
+```markdown
+# Code Patterns - {Project}
+
+> Generated: {GetTimestamp()}
+
+## Patterns Detected
+- **{Pattern}**: {Where} - {Example}
+
+## SOLID Compliance
+| Principle | Status | Evidence |
+|-----------|--------|----------|
+| Single Responsibility | ✅/⚠️/❌ | {evidence} |
+| Open/Closed | ✅/⚠️/❌ | {evidence} |
+| Liskov Substitution | ✅/⚠️/❌ | {evidence} |
+| Interface Segregation | ✅/⚠️/❌ | {evidence} |
+| Dependency Inversion | ✅/⚠️/❌ | {evidence} |
+
+## Conventions (MUST FOLLOW)
+- Functions: {camelCase/snake_case}
+- Classes: {PascalCase}
+- Files: {kebab-case/camelCase}
+- Quotes: {single/double}
+- Async: {async-await/promises}
+
+## Anti-Patterns ⚠️
+
+### High Priority
+1. **{Issue}**: {file:line} - Fix: {action}
+
+### Medium Priority
+1. **{Issue}**: {file:line} - Fix: {action}
+
+## Recommendations
+1. {Immediate action}
+2. {Best practice}
+```
+
+## Rules
+
+1. Check patterns.md FIRST before writing code
+2. Match conventions exactly
+3. NEVER introduce anti-patterns
+4. Warn if asked to violate patterns

package/templates/commands/done.md

@@ -1,23 +1,137 @@
 ---
 allowed-tools: [Read, Write]
-description: 'Complete task'
-think-triggers: [report_complete]
+description: 'Complete current task'
+timestamp-rule: 'GetTimestamp() for all timestamps'
 ---
 
-# /p:done
+# /p:done - Complete Current Task
 
-## Think First
-Before marking complete, verify:
-1. Is the task actually finished?
-2. Were all acceptance criteria met?
-3. Should this trigger a /p:ship?
+## Context Variables
+- `{projectId}`: From `.prjct/prjct.config.json`
+- `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
+- `{nowPath}`: `{globalPath}/core/now.md`
+- `{memoryPath}`: `{globalPath}/memory/context.jsonl`
+- `{metricsPath}`: `{globalPath}/progress/metrics.md`
 
-## Check
-Requires: `core/now.md` has content
+## Step 1: Read Config
 
-## Flow
-1. Read `core/now.md` → calculate duration
-2. Clear now.md → Update metrics → Log
+READ: `.prjct/prjct.config.json`
+EXTRACT: `projectId`
 
-## Response
-`✅ {task} ({duration}) | Next: /p:now or /p:ship`
+IF file not found:
+  OUTPUT: "No prjct project. Run /p:init first."
+  STOP
+
+## Step 2: Validate Active Task
+
+READ: `{nowPath}`
+
+IF empty OR contains "No current task":
+  OUTPUT: "⚠️ No active task to complete. Use /p:now to start one."
+  STOP
+
+## Step 3: Extract Task Data
+
+From NOW file content, extract:
+
+1. **Task name**: Text between `**` markers
+   - Pattern: `**(.+?)**`
+   - Example: `**implement auth**` → "implement auth"
+
+2. **Start time**: Text after "Started:"
+   - Pattern: `Started: (.+)`
+   - Example: `Started: 11/28/2025, 2:30:00 PM`
+
+3. **Calculate duration**:
+   - Current: GetTimestamp()
+   - Duration: current - started
+   - Format: "Xh Ym" (e.g., "2h 15m")
+   - If < 1 hour: "Xm"
+   - If < 1 minute: "< 1m"
+
+## Step 4: Clear Task File
+
+WRITE: `{nowPath}`
+
+Content (exact):
+```markdown
+# NOW
+
+No current task. Use `/p:now` to set focus.
+```
+
+## Step 5: Log to Memory
+
+APPEND to: `{memoryPath}`
+
+Single line (JSONL format):
+```json
+{"timestamp":"{GetTimestamp()}","action":"task_completed","task":"{task}","duration":"{duration}"}
+```
+
+## Step 6: Update Metrics (Optional)
+
+IF `{metricsPath}` exists:
+  READ current content
+  APPEND new entry with task and duration
+
+## Output
+
+SUCCESS:
+```
+✅ {task} ({duration})
+
+Next:
+• /p:now - Start next task
+• /p:ship - Ship completed work
+• /p:next - See priority queue
+```
+
+## Error Handling
+
+| Error | Response |
+|-------|----------|
+| Config not found | "No prjct project. Run /p:init first." |
+| Now.md empty | "⚠️ No active task. Use /p:now to start." |
+| Parse fails | Use task = "task", duration = "unknown", continue |
+| Write fails | Log warning, continue (non-critical) |
+
+## Examples
+
+### Example 1: Success
+**now.md content:**
+```
+# NOW
+
+**implement authentication**
+
+Started: 11/28/2025, 12:15:00 PM
+```
+
+**Current time:** 11/28/2025, 2:30:00 PM
+**Duration:** 2h 15m
+**Output:** `✅ implement authentication (2h 15m)`
+
+### Example 2: No Task
+**now.md content:**
+```
+# NOW
+
+No current task.
+```
+
+**Output:** `⚠️ No active task to complete. Use /p:now to start one.`
+
+### Example 3: Quick Task
+**now.md content:**
+```
+# NOW
+
+**fix typo in readme**
+
+Started: 11/28/2025, 2:25:00 PM
+```
+
+**Current time:** 11/28/2025, 2:30:00 PM
+**Duration:** 5m
+**Output:** `✅ fix typo in readme (5m)`