prjct-cli 0.10.8 → 0.10.9

package/CHANGELOG.md

@@ -1,5 +1,42 @@
 # Changelog
 
+## [0.10.9] - 2025-11-28
+
+### Added
+
+- **Code Pattern Detection & Enforcement** - New system to detect and enforce code patterns
+  - `templates/analysis/patterns.md` - Template for detecting SOLID, DRY, naming conventions
+  - Detects design patterns: Factory, Singleton, Observer, Repository, Strategy
+  - Identifies anti-patterns: God classes, spaghetti code, copy-paste, magic numbers
+  - Extracts conventions: naming, style, async patterns, error handling
+  - Generates recommendations with specific file locations and fixes
+
+### Enhanced
+
+- **`/p:sync` Command** - Now includes pattern analysis
+  - Samples 5-10 source files across directories
+  - Detects SOLID compliance with evidence
+  - Extracts naming and style conventions
+  - Flags anti-patterns with severity (HIGH/MEDIUM/LOW)
+  - Saves analysis to `analysis/patterns.md`
+  - Updates CLAUDE.md with patterns summary
+
+- **Context Builder** - Added `codePatterns` path for pattern detection
+  - All code-modifying commands now load patterns automatically
+  - Commands: now, build, feature, design, cleanup, fix, test, spec, work
+
+- **Prompt Builder** - Includes patterns in code generation prompts
+  - Full patterns file included for code-modifying commands
+  - Explicit instruction: "ALL new code MUST respect these patterns"
+  - Anti-pattern prevention: "NO anti-patterns allowed"
+
+### Impact
+
+- New code automatically follows project conventions
+- Anti-patterns detected and flagged before they're introduced
+- Better code quality, performance, and scalability
+- Reduced technical debt from day one
+
 ## [0.10.8] - 2025-11-28
 
 ### Added

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

@@ -113,11 +113,20 @@ class PromptBuilder {
     }
 
     // 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']
+    // 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
+    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 analysisContent = state?.analysis || ''
     if (needsPatterns && analysisContent && analysisContent.trim()) {
       // Extract stack info compactly
@@ -125,8 +134,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 +201,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 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.10.8",
+  "version": "0.10.9",
   "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,206 @@
+---
+allowed-tools: [Read, Glob, Grep]
+description: 'Analyze code patterns, conventions, and anti-patterns'
+---
+
+# Code Pattern Analysis
+
+## Objective
+
+Detect code patterns, conventions, and anti-patterns to ensure ALL new code respects the project's established practices.
+
+## 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:
+
+```markdown
+# Code Patterns - {Project Name}
+
+> Auto-generated by /p:sync
+> Last analyzed: {timestamp}
+
+## Design Patterns Detected
+
+### Applied Patterns ✅
+- **{Pattern}**: {Where used} - {Example}
+
+### SOLID Compliance
+| Principle | Status | Evidence |
+|-----------|--------|----------|
+| Single Responsibility | ✅/⚠️/❌ | {evidence} |
+| Open/Closed | ✅/⚠️/❌ | {evidence} |
+| Liskov Substitution | ✅/⚠️/❌ | {evidence} |
+| Interface Segregation | ✅/⚠️/❌ | {evidence} |
+| Dependency Inversion | ✅/⚠️/❌ | {evidence} |
+
+## Conventions (MUST FOLLOW)
+
+### Naming
+- Functions: {convention}
+- Classes: {convention}
+- Files: {convention}
+- Constants: {convention}
+
+### Style
+- Semicolons: {yes/no}
+- Quotes: {single/double}
+- Async: {async-await/promises/callbacks}
+
+### Structure
+- Exports: {single/multiple per file}
+- Max file size: {observed max}
+- Directory organization: {pattern}
+
+## Anti-Patterns Found ⚠️
+
+### High Priority
+1. **{Anti-pattern}**: {file:line}
+   - Problem: {description}
+   - Fix: {recommendation}
+
+### Medium Priority
+1. **{Anti-pattern}**: {file:line}
+   - Problem: {description}
+   - Fix: {recommendation}
+
+## 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.
+```
+
+## 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
+
+---
+
+**Remember**: Quality > Speed. Anti-patterns create technical debt.

package/templates/commands/sync.md

@@ -1,17 +1,71 @@
 ---
-allowed-tools: [Read, Write, Bash, TodoWrite]
-description: 'Sync state + generate agents'
+allowed-tools: [Read, Write, Bash, Glob, Grep, TodoWrite]
+description: 'Sync state + generate agents + detect patterns'
 ---
 
 # /p:sync
 
 ## Flow
-1. Execute `/p:analyze`
-2. Read `analysis/repo-summary.md`
-3. Generate agents per technology → `agents/`
-4. Log to memory
+
+1. Execute `/p:analyze` → generates `analysis/repo-summary.md`
+2. Execute pattern analysis → generates `analysis/patterns.md`
+3. Read both analysis files
+4. Generate agents per technology → `agents/`
+5. Update `CLAUDE.md` with patterns summary
+6. Log to memory
+
+## Pattern Analysis (Step 2)
+
+Read `templates/analysis/patterns.md` and execute:
+
+1. **Sample 5-10 source files** across different directories
+2. **Detect design patterns**: SOLID, DRY, factories, etc.
+3. **Extract conventions**: naming, style, structure
+4. **Flag anti-patterns**: god classes, duplication, mixed concerns
+5. **Generate recommendations**: immediate fixes + best practices
+
+### Key Files to Analyze
+```
+- Main entry point (bin/, src/index, main)
+- Largest source files (potential god classes)
+- Utility/helper directories (DRY evidence)
+- Test files (testing patterns)
+- Config files (tooling conventions)
+```
+
+### Output
+Save to `analysis/patterns.md` with:
+- Detected patterns (what to follow)
+- Conventions (MUST match in new code)
+- Anti-patterns found (with fixes)
+- Recommendations (for quality)
+
+## Agent Generation (Step 4)
 
 Use: `generateDynamicAgent(name, config)`
 
+## CLAUDE.md Update (Step 5)
+
+Add patterns summary section:
+```markdown
+## Code Patterns
+
+**Follow these patterns in ALL new code:**
+- {key conventions from patterns.md}
+- {design patterns to apply}
+
+**Avoid these anti-patterns:**
+- {detected anti-patterns}
+```
+
 ## Response
-`🔄 Synced | Generated: {agents} | Next: /p:context`
+
+```
+🔄 Synced
+├── Stack: {languages/frameworks}
+├── Agents: {count} generated
+├── Patterns: {count} detected
+└── Anti-patterns: {count} flagged
+
+Next: /p:context or /p:now
+```