prjct-cli 0.10.9 → 0.10.10

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,38 +70,30 @@ 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 done, ship, recap, next don't need full patterns
     const codeCommands = ['now', 'build', 'feature', 'design', 'cleanup', 'fix', 'bug', 'test', 'init', 'spec', 'work']
-    const commandName = template.frontmatter?.name?.replace('p:', '') || ''
     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()) {
-      parts.push('\n## CODE PATTERNS (MUST FOLLOW)\n')
-      // Include the full patterns file - it contains critical conventions
-      parts.push(codePatternsContent)
-      parts.push('\n**ALL new code MUST respect these patterns. NO anti-patterns allowed.**\n')
+      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 || ''
@@ -243,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.9",
+  "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

@@ -1,142 +1,29 @@
 ---
 allowed-tools: [Read, Glob, Grep]
-description: 'Analyze code patterns, conventions, and anti-patterns'
+description: 'Analyze code patterns and conventions'
 ---
 
 # Code Pattern Analysis
 
-## Objective
+## Detection Steps
 
-Detect code patterns, conventions, and anti-patterns to ensure ALL new code respects the project's established practices.
+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
 
-## Step 1: Analyze Code Structure
-
-### File Organization
-- Read 5-10 representative source files
-- Identify: single vs multiple exports per file
-- Check: file size patterns (small focused files vs large files)
-- Note: directory organization (by feature, by layer, by type)
-
-### Module Patterns
-- ES Modules vs CommonJS
-- Default exports vs named exports
-- Barrel files (index.js re-exports)
-- Circular dependency patterns
-
-## Step 2: Detect Design Patterns
-
-### SOLID Principles
-Analyze for evidence of:
-
-| Principle | Look For | Example |
-|-----------|----------|---------|
-| **S**ingle Responsibility | Small, focused files/functions | `validateUser()` not `validateAndSaveUser()` |
-| **O**pen/Closed | Extension points, plugins | Base classes, strategy pattern |
-| **L**iskov Substitution | Interface consistency | Subclasses behave like parents |
-| **I**nterface Segregation | Small, specific interfaces | Multiple small interfaces vs one large |
-| **D**ependency Inversion | Dependency injection | Constructor injection, factories |
-
-### DRY (Don't Repeat Yourself)
-- Check for utility/helper directories
-- Look for shared constants
-- Identify reusable components/functions
-- Note any obvious duplication
-
-### Other Patterns
-- Factory pattern (createX functions)
-- Singleton pattern (shared instances)
-- Observer pattern (event emitters)
-- Repository pattern (data access layer)
-- Strategy pattern (interchangeable algorithms)
-
-## Step 3: Identify Conventions
-
-### Naming Conventions
-```
-Analyze actual code for:
-- Functions: camelCase, snake_case, PascalCase?
-- Classes: PascalCase?
-- Constants: UPPER_SNAKE_CASE?
-- Files: kebab-case, camelCase, PascalCase?
-- Private members: _prefix, #private?
-```
-
-### Code Style
-- Semicolons: yes/no
-- Quotes: single/double
-- Indentation: tabs/spaces (2/4)
-- Trailing commas: yes/no
-- Max line length observed
-
-### Error Handling
-- Try-catch patterns
-- Custom error classes
-- Error propagation (throw vs return)
-- Logging patterns
-
-### Async Patterns
-- async/await vs Promises vs callbacks
-- Error handling in async code
-- Parallel execution patterns
-
-## Step 4: Detect Anti-Patterns
-
-### Code Smells (Flag These)
-
-| Anti-Pattern | Detection | Severity |
-|--------------|-----------|----------|
-| **God Class/File** | File > 300 lines, too many responsibilities | HIGH |
-| **Spaghetti Code** | Deep nesting > 4 levels, unclear flow | HIGH |
-| **Copy-Paste Code** | Duplicate blocks across files | MEDIUM |
-| **Magic Numbers** | Hardcoded values without constants | MEDIUM |
-| **Long Functions** | Function > 50 lines | MEDIUM |
-| **Too Many Parameters** | Function with > 4 params | LOW |
-| **Dead Code** | Commented out code, unused exports | LOW |
-| **Mixed Concerns** | I/O mixed with business logic | MEDIUM |
-| **Callback Hell** | Nested callbacks > 3 levels | HIGH |
-| **Mutable Global State** | Global variables modified everywhere | HIGH |
-
-### Architecture Smells
-
-| Anti-Pattern | Detection | Recommendation |
-|--------------|-----------|----------------|
-| **Circular Dependencies** | A imports B, B imports A | Extract shared module |
-| **Feature Envy** | Function uses other module's data excessively | Move function to that module |
-| **Inappropriate Intimacy** | Classes know too much about each other | Use interfaces/abstractions |
-| **Lazy Class** | Class does almost nothing | Merge with related class |
-| **Speculative Generality** | Unused abstractions "for future" | Remove until needed |
-
-## Step 5: Performance Patterns
-
-### Good Patterns to Note
-- Memoization usage
-- Lazy loading
-- Caching strategies
-- Batch operations
-- Connection pooling
-
-### Performance Anti-Patterns
-- N+1 queries
-- Synchronous I/O in loops
-- Memory leaks (unclosed resources)
-- Unbounded data structures
-
-## Output Format
-
-Generate `analysis/patterns.md` with:
+## Output: analysis/patterns.md
 
 ```markdown
-# Code Patterns - {Project Name}
+# Code Patterns - {Project}
 
-> Auto-generated by /p:sync
-> Last analyzed: {timestamp}
+> Generated: {GetTimestamp()}
 
-## Design Patterns Detected
+## Patterns Detected
+- **{Pattern}**: {Where} - {Example}
 
-### Applied Patterns ✅
-- **{Pattern}**: {Where used} - {Example}
-
-### SOLID Compliance
+## SOLID Compliance
 | Principle | Status | Evidence |
 |-----------|--------|----------|
 | Single Responsibility | ✅/⚠️/❌ | {evidence} |
@@ -146,61 +33,28 @@ Generate `analysis/patterns.md` with:
 | Dependency Inversion | ✅/⚠️/❌ | {evidence} |
 
 ## Conventions (MUST FOLLOW)
-
-### Naming
-- Functions: {convention}
-- Classes: {convention}
-- Files: {convention}
-- Constants: {convention}
-
-### Style
-- Semicolons: {yes/no}
+- Functions: {camelCase/snake_case}
+- Classes: {PascalCase}
+- Files: {kebab-case/camelCase}
 - Quotes: {single/double}
-- Async: {async-await/promises/callbacks}
-
-### Structure
-- Exports: {single/multiple per file}
-- Max file size: {observed max}
-- Directory organization: {pattern}
+- Async: {async-await/promises}
 
-## Anti-Patterns Found ⚠️
+## Anti-Patterns ⚠️
 
 ### High Priority
-1. **{Anti-pattern}**: {file:line}
-   - Problem: {description}
-   - Fix: {recommendation}
+1. **{Issue}**: {file:line} - Fix: {action}
 
 ### Medium Priority
-1. **{Anti-pattern}**: {file:line}
-   - Problem: {description}
-   - Fix: {recommendation}
+1. **{Issue}**: {file:line} - Fix: {action}
 
 ## Recommendations
-
-### Immediate Actions
-1. {Action with specific file/location}
-
-### Best Practices for New Code
-1. {Practice based on detected patterns}
-2. {Practice based on conventions}
-3. {Practice to avoid anti-patterns}
-
----
-
-**IMPORTANT**: All new code MUST follow these patterns and conventions.
+1. {Immediate action}
+2. {Best practice}
 ```
 
-## Integration Rules
-
-When generating new code, Claude MUST:
-
-1. **Check patterns.md FIRST** before writing any code
-2. **Match naming conventions** exactly as detected
-3. **Follow file structure** patterns (size, organization)
-4. **Apply detected design patterns** where appropriate
-5. **NEVER introduce anti-patterns** listed in the analysis
-6. **Warn if asked to violate** established patterns
-
----
+## Rules
 
-**Remember**: Quality > Speed. Anti-patterns create technical debt.
+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)`