prjct-cli 0.10.6 → 0.10.9

package/CHANGELOG.md

@@ -1,5 +1,112 @@
 # 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
+
+- **Minimal Output System** - New `core/utils/output.js` module for clean, minimal CLI output
+  - `spin(msg)` - Spinner animation while working
+  - `done(msg)` - Single-line success output (✓)
+  - `fail(msg)` - Single-line error output (✗)
+  - `warn(msg)` - Single-line warning output (⚠)
+
+### Changed
+
+- **Reduced CLI Verbosity** - All major commands now show spinner + 1 line result instead of verbose multi-line output
+  - `/p:now` - Shows only task name and status
+  - `/p:done` - Shows task and duration in one line
+  - `/p:next` - Shows queue count only
+  - `/p:ship` - Spinner during steps, single line result with version
+  - `/p:feature` - Shows task count created
+  - `/p:init` - Spinner during initialization, minimal completion message
+  - `/p:bug` - Shows severity in one line
+  - `/p:context` - Shows task and queue summary
+  - `/p:recap` - Shows shipped/queue/ideas counts
+  - `/p:stuck` - Logs issue with minimal output
+  - `/p:design` - Shows design type created
+  - `/p:cleanup` - Shows items cleaned count
+  - `/p:progress` - Shows period metrics summary
+  - `/p:roadmap` - Shows features count
+
+### Improved
+
+- **Resource Efficiency** - Reduced terminal output significantly, consuming less resources
+- **Cleaner UX** - Focus on essential information, no verbose step-by-step logs
+
+## [0.10.7] - 2025-11-27
+
+### Fixed
+
+- **Critical Git Safety** - Added explicit protections against destructive git operations
+  - Prohibits `git checkout` without checking for uncommitted changes first
+  - Prohibits `git reset --hard` and `git clean -fd` operations
+  - Requires `git status` check before any git operation
+  - Prevents loss of user's work through accidental git operations
+
+- **Anti-Hallucination Improvements** - Enhanced instructions to prevent code hallucinations
+  - Explicit "READ CODE FIRST" requirement before modifying files
+  - Mandatory pattern matching with existing codebase
+  - Improved context awareness with file listings
+  - Better state filtering to preserve critical information (up to 2000 chars for critical files)
+
+### Enhanced
+
+- **Pattern Detection & Enforcement** - Automatic project pattern detection and enforcement
+  - Analysis file (`analysis/repo-summary.md`) automatically loaded for all code modification commands
+  - Project patterns extracted and displayed in prompts
+  - Explicit instructions to follow existing patterns exactly
+  - Step-by-step guide to match code style, structure, and conventions
+
+- **Context Improvements** - Better context loading and presentation
+  - Analysis included automatically for: now, done, next, ship, work, build, design, cleanup, fix, test
+  - Project files listed with instructions to use Read tool
+  - State filtering improved to show full content for critical files (now, next, context, analysis)
+  - Better truncation strategy (full content < 1000 chars, 2000 chars for critical files)
+
+- **Prompt Builder Enhancements** - More comprehensive instructions for Claude
+  - Anti-hallucination section with 7 critical rules
+  - Git safety rules with explicit prohibitions
+  - Pattern detection and enforcement section
+  - Available project files listing
+  - Improved enforcement section with pattern matching requirement
+
 ## [0.10.6] - 2025-11-27
 
 ### Enhanced

package/core/__tests__/agentic/prompt-builder.test.js

@@ -0,0 +1,244 @@
+/**
+ * Prompt Builder Tests
+ * Tests for optimized prompts with compressed rules
+ *
+ * OPTIMIZED: Tests updated to match compressed prompt structure
+ */
+
+import { describe, it, expect, beforeEach } from 'vitest'
+import promptBuilder from '../../agentic/prompt-builder.js'
+
+describe('PromptBuilder', () => {
+  let builder
+
+  beforeEach(() => {
+    builder = promptBuilder
+    builder._currentContext = null
+  })
+
+  describe('Critical Rules (Compressed)', () => {
+    it('should include git safety rules', () => {
+      builder._currentContext = { files: [], filteredSize: 0 }
+      const rules = builder.buildCriticalRules()
+
+      expect(rules).toContain('GIT SAFETY')
+      expect(rules).toContain('checkout')
+      expect(rules).toContain('reset')
+    })
+
+    it('should include read-first requirement', () => {
+      builder._currentContext = { files: [], filteredSize: 0 }
+      const rules = builder.buildCriticalRules()
+
+      expect(rules).toContain('READ FIRST')
+      expect(rules).toContain('Read tool')
+    })
+
+    it('should include pattern matching requirement', () => {
+      builder._currentContext = { files: [], filteredSize: 0 }
+      const rules = builder.buildCriticalRules()
+
+      expect(rules).toContain('MATCH PATTERNS')
+    })
+
+    it('should include no-hallucination rules', () => {
+      builder._currentContext = { files: [], filteredSize: 0 }
+      const rules = builder.buildCriticalRules()
+
+      expect(rules).toContain('NO HALLUCINATIONS')
+    })
+
+    it('should show file count in context', () => {
+      builder._currentContext = { files: ['a.js', 'b.js', 'c.js'] }
+      const rules = builder.buildCriticalRules()
+
+      expect(rules).toContain('3 files available')
+    })
+  })
+
+  describe('State Filtering', () => {
+    it('should preserve full content for critical files', () => {
+      const state = {
+        now: '# NOW\n\n**Test task**\n\nStarted: 2025-01-01',
+        next: '# NEXT\n\n## Priority Queue\n\n1. Task 1',
+        context: 'Project context information',
+        analysis: 'Stack: Node.js\nPatterns: ES6 modules',
+        metrics: 'Some metrics data'
+      }
+
+      const filtered = builder.filterRelevantState(state)
+
+      expect(filtered).toContain('### now')
+      expect(filtered).toContain('Test task')
+      expect(filtered).toContain('### next')
+      expect(filtered).toContain('### context')
+      expect(filtered).toContain('### analysis')
+    })
+
+    it('should truncate large non-critical files', () => {
+      const largeContent = 'x'.repeat(2000)
+      const state = {
+        now: '# NOW\n\n**Task**',
+        largeFile: largeContent
+      }
+
+      const filtered = builder.filterRelevantState(state)
+
+      expect(filtered).toContain('### now')
+      expect(filtered).toContain('### largeFile')
+      expect(filtered).toContain('truncated')
+    })
+
+    it('should return null for empty state', () => {
+      const filtered = builder.filterRelevantState({})
+      expect(filtered).toBeNull()
+    })
+  })
+
+  describe('Context Filtering by Command Type', () => {
+    it('should include patterns for code commands', () => {
+      const template = {
+        frontmatter: { description: 'Build feature', name: 'p:build' },
+        content: '## Flow\nBuild something'
+      }
+
+      const context = { projectPath: '/test', files: ['file1.js'] }
+      const state = { analysis: 'Stack: Node.js, React' }
+
+      const prompt = builder.build(template, context, state)
+
+      expect(prompt).toContain('PATTERNS')
+      expect(prompt).toContain('Node.js')
+    })
+
+    it('should NOT include patterns for non-code commands', () => {
+      const template = {
+        frontmatter: { description: 'Show current task', name: 'p:now' },
+        content: '## Flow\nShow task'
+      }
+
+      const context = { projectPath: '/test', files: ['file1.js'] }
+      const state = { analysis: 'Stack: Node.js, React' }
+
+      const prompt = builder.build(template, context, state)
+
+      // Non-code commands should NOT include patterns section
+      expect(prompt).not.toContain('## PATTERNS')
+    })
+  })
+
+  describe('Project Files Listing', () => {
+    it('should list available files when context has files', () => {
+      const template = {
+        frontmatter: { description: 'Test command' },
+        content: '## Flow\nDo something'
+      }
+
+      const context = {
+        projectPath: '/test',
+        files: ['src/file1.js', 'src/file2.js', 'tests/test1.js']
+      }
+
+      const state = {}
+
+      const prompt = builder.build(template, context, state)
+
+      expect(prompt).toContain('AVAILABLE PROJECT FILES')
+      expect(prompt).toContain('file1.js')
+      expect(prompt).toContain('Read')
+    })
+
+    it('should show project path when no files listed', () => {
+      const template = {
+        frontmatter: { description: 'Test command' },
+        content: '## Flow\nDo something'
+      }
+
+      const context = { projectPath: '/test/project' }
+      const state = {}
+
+      const prompt = builder.build(template, context, state)
+
+      expect(prompt).toContain('PROJECT FILES')
+      expect(prompt).toContain('/test/project')
+    })
+  })
+
+  describe('Build Complete Prompt', () => {
+    it('should include all critical sections', () => {
+      const template = {
+        frontmatter: {
+          description: 'Test command',
+          'allowed-tools': ['Read', 'Write']
+        },
+        content: '## Flow\n1. Do step 1\n2. Do step 2'
+      }
+
+      const context = {
+        projectPath: '/test',
+        params: { task: 'test task' },
+        files: ['file1.js']
+      }
+
+      const state = { now: '# NOW\n\n**Current task**' }
+
+      const prompt = builder.build(template, context, state)
+
+      expect(prompt).toContain('TASK:')
+      expect(prompt).toContain('TOOLS:')
+      expect(prompt).toContain('Flow')
+      expect(prompt).toContain('RULES (CRITICAL)')
+      expect(prompt).toContain('AVAILABLE PROJECT FILES')
+    })
+
+    it('should be concise (under 2000 chars for simple prompt)', () => {
+      const template = {
+        frontmatter: { description: 'Test', 'allowed-tools': ['Read'] },
+        content: '## Flow\n1. Test'
+      }
+
+      const context = { projectPath: '/test', files: ['a.js'] }
+      const state = {}
+
+      const prompt = builder.build(template, context, state)
+
+      // Optimized prompts should be under 2000 chars for simple cases
+      expect(prompt.length).toBeLessThan(2000)
+    })
+  })
+
+  describe('Plan Mode (Compressed)', () => {
+    it('should include compact plan mode instructions', () => {
+      const template = {
+        frontmatter: { description: 'Test' },
+        content: '## Flow\nTest'
+      }
+
+      const context = { projectPath: '/test' }
+      const state = {}
+      const planInfo = { isPlanning: true, allowedTools: ['Read', 'Glob'] }
+
+      const prompt = builder.build(template, context, state, null, null, null, null, planInfo)
+
+      expect(prompt).toContain('PLAN MODE')
+      expect(prompt).toContain('Read-only')
+      expect(prompt).toContain('Tools: Read, Glob')
+    })
+
+    it('should include approval required section', () => {
+      const template = {
+        frontmatter: { description: 'Test' },
+        content: '## Flow\nTest'
+      }
+
+      const context = { projectPath: '/test' }
+      const state = {}
+      const planInfo = { requiresApproval: true }
+
+      const prompt = builder.build(template, context, state, null, null, null, null, planInfo)
+
+      expect(prompt).toContain('APPROVAL REQUIRED')
+      expect(prompt).toContain('confirmation')
+    })
+  })
+})

package/core/__tests__/utils/output.test.js

@@ -0,0 +1,163 @@
+/**
+ * Output Module Tests
+ * Minimal output system for prjct-cli
+ */
+
+const out = require('../../utils/output')
+
+describe('Output Module', () => {
+  let consoleLogSpy
+  let stdoutWriteSpy
+
+  beforeEach(() => {
+    // Mock console.log
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {})
+    // Mock process.stdout.write
+    stdoutWriteSpy = vi.spyOn(process.stdout, 'write').mockImplementation(() => {})
+    // Ensure spinner is stopped before each test
+    out.stop()
+  })
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore()
+    stdoutWriteSpy.mockRestore()
+    out.stop()
+  })
+
+  describe('done()', () => {
+    it('should output success message with checkmark', () => {
+      out.done('task completed')
+
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+      const output = consoleLogSpy.mock.calls[0][0]
+      expect(output).toContain('✓')
+      expect(output).toContain('task completed')
+    })
+
+    it('should truncate long messages', () => {
+      const longMessage = 'a'.repeat(100)
+      out.done(longMessage)
+
+      const output = consoleLogSpy.mock.calls[0][0]
+      // Should be truncated to ~65 chars + checkmark
+      expect(output.length).toBeLessThan(80)
+    })
+
+    it('should return self for chaining', () => {
+      const result = out.done('test')
+      expect(result).toBe(out)
+    })
+  })
+
+  describe('fail()', () => {
+    it('should output error message with X mark', () => {
+      out.fail('something failed')
+
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+      const output = consoleLogSpy.mock.calls[0][0]
+      expect(output).toContain('✗')
+      expect(output).toContain('something failed')
+    })
+
+    it('should truncate long error messages', () => {
+      const longMessage = 'error '.repeat(50)
+      out.fail(longMessage)
+
+      const output = consoleLogSpy.mock.calls[0][0]
+      expect(output.length).toBeLessThan(80)
+    })
+
+    it('should return self for chaining', () => {
+      const result = out.fail('test')
+      expect(result).toBe(out)
+    })
+  })
+
+  describe('warn()', () => {
+    it('should output warning message with warning symbol', () => {
+      out.warn('be careful')
+
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1)
+      const output = consoleLogSpy.mock.calls[0][0]
+      expect(output).toContain('⚠')
+      expect(output).toContain('be careful')
+    })
+
+    it('should return self for chaining', () => {
+      const result = out.warn('test')
+      expect(result).toBe(out)
+    })
+  })
+
+  describe('spin()', () => {
+    it('should start spinner with message', () => {
+      vi.useFakeTimers()
+
+      out.spin('loading')
+
+      // Advance timer to trigger interval
+      vi.advanceTimersByTime(100)
+
+      expect(stdoutWriteSpy).toHaveBeenCalled()
+      const output = stdoutWriteSpy.mock.calls[0][0]
+      expect(output).toContain('loading')
+
+      out.stop()
+      vi.useRealTimers()
+    })
+
+    it('should return self for chaining', () => {
+      const result = out.spin('test')
+      out.stop()
+      expect(result).toBe(out)
+    })
+  })
+
+  describe('stop()', () => {
+    it('should stop spinner and clear line', () => {
+      vi.useFakeTimers()
+
+      out.spin('loading')
+      vi.advanceTimersByTime(100)
+
+      stdoutWriteSpy.mockClear()
+      out.stop()
+
+      // Should write clearing spaces
+      expect(stdoutWriteSpy).toHaveBeenCalled()
+
+      vi.useRealTimers()
+    })
+
+    it('should be safe to call multiple times', () => {
+      expect(() => {
+        out.stop()
+        out.stop()
+        out.stop()
+      }).not.toThrow()
+    })
+
+    it('should return self for chaining', () => {
+      const result = out.stop()
+      expect(result).toBe(out)
+    })
+  })
+
+  describe('edge cases', () => {
+    it('should handle empty messages', () => {
+      expect(() => out.done('')).not.toThrow()
+      expect(() => out.fail('')).not.toThrow()
+      expect(() => out.warn('')).not.toThrow()
+    })
+
+    it('should handle null/undefined messages', () => {
+      expect(() => out.done(null)).not.toThrow()
+      expect(() => out.done(undefined)).not.toThrow()
+    })
+
+    it('should handle messages with special characters', () => {
+      out.done('test with émojis 🎉 and spëcial çhars')
+      expect(consoleLogSpy).toHaveBeenCalled()
+    })
+  })
+})