prjct-cli 0.10.6 → 0.10.9

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/analysis/project-analysis.md

@@ -0,0 +1,78 @@
+---
+allowed-tools: [Read, Glob, Bash]
+description: 'Analyze project technology stack - Claude reads and decides'
+---
+
+# Project Analysis Instructions
+
+## Objective
+
+Determine the technology stack by READING actual files, not assuming.
+
+## Step 1: Read Dependency Files
+
+Read these files if they exist:
+
+- `package.json` → Node.js/JavaScript/TypeScript project
+- `Cargo.toml` → Rust project
+- `go.mod` → Go project
+- `requirements.txt` or `pyproject.toml` → Python project
+- `Gemfile` → Ruby project
+- `mix.exs` → Elixir project
+- `pom.xml` or `build.gradle` → Java project
+- `composer.json` → PHP project
+
+**Extract actual dependencies** - don't guess frameworks.
+
+## Step 2: Examine Directory Structure
+
+List the root directory to identify:
+
+- Source directories (src/, lib/, app/, cmd/)
+- Test directories (tests/, spec/, __tests__/)
+- Config directories (.github/, .gitlab/, .vscode/)
+- Build outputs (dist/, build/, target/)
+
+## Step 3: Check Configuration Files
+
+Look for:
+
+- `tsconfig.json` → TypeScript configuration
+- `Dockerfile` → Docker usage
+- `docker-compose.yml` → Multi-container setup
+- `.eslintrc`, `.prettierrc` → Linting/formatting
+- `jest.config.js`, `vitest.config.ts` → Testing setup
+- `.env*` files → Environment configuration
+
+## Step 4: Determine Stack
+
+Based on what you READ (not assumed):
+
+1. **Languages**: Identify from file extensions and configs
+2. **Frameworks**: Extract from actual dependencies
+3. **Tools**: Identify from config files present
+4. **Databases**: Look for DB clients in dependencies
+5. **Testing**: Identify test frameworks from configs/deps
+
+## Output Format
+
+Provide analysis in this structure:
+
+```json
+{
+  "languages": ["actual languages found"],
+  "frameworks": ["actual frameworks from deps"],
+  "tools": ["tools with config files present"],
+  "databases": ["database clients in deps"],
+  "testing": ["test frameworks found"],
+  "notes": "any observations about the project"
+}
+```
+
+## Rules
+
+- **NO hardcoded assumptions** - React doesn't mean "frontend"
+- **READ before deciding** - Don't guess based on filenames
+- **Any stack works** - Elixir, Rust, Go, Python, etc.
+- **Be specific** - Include versions when available
+- **Note uncertainty** - If unclear, say so

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
+```