Development Plugin

1# Development Plugin
2 
3Code development and quality assurance tools for systematic analysis, testing, debugging, and review.
4 
5## Overview
6 
7The Development plugin provides essential tools for building high-quality code. It includes commands for codebase analysis, test-driven development, debugging, code execution, and comprehensive code review. Three specialized agents provide expert assistance for architecture, testing, and code quality.
8 
9## Features
10 
11- **Deep Analysis**: Semantic codebase understanding with architecture insights
12- **Test-Driven Development**: Comprehensive TDD workflow with test generation
13- **Universal Debugging**: Fix errors, bugs, and code issues with semantic analysis
14- **Safe Execution**: Run scripts and code with monitoring and timeout control
15- **Code Review**: Systematic review for bugs, design flaws, and quality issues
16- **External Review Prep**: Package codebase for external review with RepoMix integration
17 
18## Commands
19 
20### `/analyze [focus_area] [--with-thinking] [--semantic]`
21Analyze ANY project to understand its structure and architecture with semantic code intelligence and structured reasoning.
22 
23**What it does**:
24- Analyzes codebase structure and organization
25- Identifies architectural patterns and design choices
26- Maps dependencies and relationships
27- Highlights potential issues and improvements
28- Generates comprehensive analysis report
29 
30**Usage**:
31```bash
32/analyze                                    # Full project analysis
33/analyze src/auth                           # Analyze specific area
34/analyze --with-thinking                    # Use structured reasoning
35/analyze --semantic                         # Use Serena semantic analysis
36/analyze src/api --with-thinking --semantic # Deep analysis with all tools
37```
38 
39**Analysis Types**:
40- **Structure**: Directory organization, module layout
41- **Architecture**: Design patterns, architectural style
42- **Dependencies**: Internal and external dependencies
43- **Quality**: Code quality metrics, technical debt
44- **Security**: Potential security issues
45- **Performance**: Performance bottlenecks
46 
47**Output**:
48- Comprehensive analysis document
49- Architectural diagrams (textual)
50- Dependency maps
51- Recommendations for improvements
52 
53**When to use**:
54- ✅ New codebase familiarization
55- ✅ Architecture review
56- ✅ Before major refactoring
57- ✅ Technical debt assessment
58- ✅ Onboarding new team members
59 
60### `/test [tdd] [pattern]`
61Test-driven development workflow using test-engineer agent. Create tests, analyze coverage, and ensure quality.
62 
63**What it does**:
64- Creates comprehensive test suites
65- Analyzes test coverage
66- Identifies untested code paths
67- Generates test cases from specifications
68- Runs tests and reports results
69 
70**Usage**:
71```bash
72/test                                       # Run existing tests
73/test tdd                                   # Start TDD workflow
74/test src/auth/*                            # Test specific pattern
75/test --coverage                            # Generate coverage report
76```
77 
78**TDD Workflow**:
791. **Write test first**: Define expected behavior
802. **Run test** (should fail initially)
813. **Implement code**: Make test pass
824. **Refactor**: Improve while keeping tests green
835. **Repeat**: Next feature
84 
85**Test Types Supported**:
86- Unit tests
87- Integration tests
88- End-to-end tests
89- Property-based tests
90- Mutation tests
91 
92**When to use**:
93- ✅ New feature development (TDD)
94- ✅ Bug fixes (regression tests)
95- ✅ Refactoring (safety net)
96- ✅ Coverage improvements
97- ✅ Quality assurance
98 
99### `/fix [error|review|audit|all] [file/pattern]`
100Universal debugging and fix application with semantic code analysis. Debug errors or apply review fixes automatically.
101 
102**What it does**:
103- Analyzes errors and exceptions
104- Identifies root causes
105- Proposes and applies fixes
106- Applies code review suggestions
107- Fixes audit findings
108 
109**Usage**:
110```bash
111/fix                                        # Fix latest error
112/fix error src/auth/login.js               # Fix specific file errors
113/fix review                                 # Apply review suggestions
114/fix audit                                  # Fix audit findings
115/fix all                                    # Fix everything
116```
117 
118**Fix Sources**:
119- **error**: Runtime errors, exceptions, crashes
120- **review**: Code review feedback
121- **audit**: Audit findings and compliance issues
122- **test**: Test failures
123- **lint**: Linter warnings and errors
124 
125**Fix Process**:
1261. Identify issue and context
1272. Analyze root cause
1283. Propose fix with explanation
1294. Apply fix (with user confirmation if risky)
1305. Verify fix resolves issue
1316. Run tests to prevent regression
132 
133**When to use**:
134- ✅ Debugging runtime errors
135- ✅ Addressing review feedback
136- ✅ Fixing test failures
137- ✅ Resolving linter issues
138- ✅ Quick fixes with confidence
139 
140### `/review [file/directory] [--spec requirements.md] [--systematic] [--semantic]`
141Standard code review focused on bugs, design flaws, dead code, and code quality with prioritized action plan.
142 
143**What it does**:
144- Reviews code for bugs and logic errors
145- Identifies design flaws and anti-patterns
146- Finds dead code and unused variables
147- Checks code quality and maintainability
148- Provides prioritized recommendations
149 
150**Usage**:
151```bash
152/review                                     # Review recent changes
153/review src/auth                            # Review directory
154/review src/auth/login.js                   # Review specific file
155/review --spec @requirements.md             # Review against spec
156/review --systematic                        # Use structured reasoning
157/review --semantic                          # Use semantic code analysis
158```
159 
160**Review Focus Areas**:
1611. **Bugs**: Logic errors, edge cases, null checks
1622. **Design**: Architecture, patterns, coupling
1633. **Dead Code**: Unused functions, variables, imports
1644. **Quality**: Readability, maintainability, naming
1655. **Security**: Vulnerabilities, input validation
1666. **Performance**: Inefficiencies, optimization opportunities
1677. **Testing**: Test coverage, test quality
168 
169**Output Format**:
170```
171HIGH Priority:
172- [BUG] Null pointer in login.js:45
173- [SECURITY] SQL injection risk in query.js:120
174 
175MEDIUM Priority:
176- [DESIGN] God class in UserService.js
177- [PERFORMANCE] N+1 query in getUsers()
178 
179LOW Priority:
180- [QUALITY] Inconsistent naming in helpers.js
181- [DEAD CODE] Unused import in utils.js
182```
183 
184**When to use**:
185- ✅ Before pull request submission
186- ✅ After completing feature
187- ✅ Regular code quality checks
188- ✅ Onboarding review
189- ✅ Security audits
190 
191### `/prepare-review [focus_area_or_context]`
192Prepare external code review package using RepoMix with intelligent file selection and token-efficient formatting.
193 
194**What it does**:
195- Intelligently selects relevant files for review
196- Includes project documentation (README, specs, PRDs)
197- Generates comprehensive review prompt
198- Creates RepoMix package in XML format (no line numbers)
199- Keeps token count <100k for external reviewer submission
200 
201**Usage**:
202```bash
203/prepare-review                                 # Generic quality review
204/prepare-review "API authentication layer"      # Focus on specific area
205/prepare-review "Data pipeline error handling"  # Focus on specific concerns
206```
207 
208**Review Package Includes**:
2091. **Review Prompt**: Clear guidance on what to review and how
2102. **Project Context**: README and specs (summarized if lengthy)
2113. **Codebase**: Token-efficient RepoMix package (XML, no line numbers)
212 
213**Output Location**:
214```
215.claude/external_reviews/YYYY-MM-DD-HHMM/
216└── review_package.md    # Complete package ready to share
217```
218 
219**Token Efficiency**:
220- Target: <100,000 tokens (ideally much less)
221- XML format for clean separation
222- No line numbers (saves 20-30% tokens)
223- Intelligent file selection (exclude utilities if not relevant)
224- Documentation summarization (50 pages → 5 pages when appropriate)
225 
226**File Selection Intelligence**:
227- **Always Include**: Main entry points, core logic, API definitions, key architecture
228- **Usually Exclude**: Tests, build artifacts, dependencies, simple utilities
229- **Focus-Dependent**: Includes files relevant to specified focus area
230 
231**Review Focus Areas** (default):
232- Architecture and overall design
233- Completeness (gaps, errors, omissions)
234- Best practices for stated goals
235- Maintainability and code quality
236- Component integration and logic
237 
238**When to use**:
239- ✅ Before major architecture decisions
240- ✅ External expert review needed
241- ✅ Complex system requiring fresh perspective
242- ✅ Onboarding senior engineer for review
243- ✅ Pre-production quality gate
244 
245**Requirements**:
246- RepoMix installed (`npm install -g repomix`) or available via `npx`
247- See: https://repomix.com
248 
249**Example Output**:
250```
251✅ External review package prepared!
252 
253Location: .claude/external_reviews/2025-11-14-0530/review_package.md
254 
255Package Summary:
256- Focus: API authentication layer
257- Files included: 12 files (core auth modules)
258- Token count: ~47,000 tokens ✅
259- Format: XML (no line numbers)
260 
261Next Steps:
2621. Review the package
2632. Copy entire review_package.md
2643. Submit to external reviewer
265```
266 
267## Agents
268 
269### Architect (`architect.md`)
270System design and architectural decisions specialist. Provides high-level design guidance.
271 
272**Expertise**:
273- System architecture and design patterns
274- Technology selection and evaluation
275- Scalability and performance architecture
276- Security architecture
277- API design and integration patterns
278 
279**Capabilities**:
280- ✅ Structured reasoning for complex decisions
281- ✅ Trade-off analysis for technology choices
282- ✅ Architectural blueprint creation
283- ✅ Design review and recommendations
284- ✅ Technical specification writing
285 
286**When to use**:
287```bash
288/agent architect "Design authentication system for multi-tenant SaaS"
289/agent architect "Evaluate microservices vs monolith for our use case"
290/agent architect "Review proposed API architecture"
291```
292 
293### Test Engineer (`test-engineer.md`)
294Test creation, coverage analysis, and quality assurance specialist.
295 
296**Expertise**:
297- Test-driven development (TDD)
298- Test suite design and organization
299- Coverage analysis and improvement
300- Testing strategies (unit, integration, e2e)
301- Test framework selection
302 
303**Capabilities**:
304- ✅ Semantic code understanding for test generation
305- ✅ Coverage gap identification
306- ✅ Test case generation from specs
307- ✅ Testing best practices
308- ✅ Test quality assessment
309 
310**When to use**:
311```bash
312/agent test-engineer "Create comprehensive tests for auth module"
313/agent test-engineer "Analyze test coverage and suggest improvements"
314/agent test-engineer "Design testing strategy for new feature"
315```
316 
317### Code Reviewer (`code-reviewer.md`)
318Code review, documentation quality, and security audit specialist.
319 
320**Expertise**:
321- Code quality and maintainability
322- Security vulnerability detection
323- Documentation completeness
324- Best practices enforcement
325- Refactoring recommendations
326 
327**Capabilities**:
328- ✅ Structured reasoning for complex reviews
329- ✅ Semantic code analysis
330- ✅ Security-focused review
331- ✅ Performance optimization suggestions
332- ✅ Comprehensive feedback with priorities
333 
334**When to use**:
335```bash
336/agent code-reviewer "Review authentication implementation for security"
337/agent code-reviewer "Assess code quality of new payment module"
338/agent code-reviewer "Review PR #123 for merge readiness"
339```
340 
341## Integration with Other Plugins
342 
343### Core Plugin
344- Uses `/agent` for invoking development agents
345- Uses `/system:status` to show analysis and review progress
346- Uses `/performance` for execution metrics
347 
348### Workflow Plugin
349- `/analyze` used during `/explore` phase
350- `/test` and `/review` used during `/ship` validation
351- `/fix` helps resolve issues blocking `/next`
352 
353### Git Plugin
354- `/review` provides feedback before git commit
355- `/fix` applies changes that git commit includes
356- Quality gates integrated with git workflow
357 
358## Configuration
359 
360### Analysis Defaults (`.claude/config.json`)
361```json
362{
363  "development": {
364    "analyze": {
365      "defaultMode": "semantic",
366      "useStructuredReasoning": true,
367      "depthLevel": "comprehensive"
368    }
369  }
370}
371```
372 
373### Test Defaults
374```json
375{
376  "development": {
377    "test": {
378      "framework": "auto-detect",
379      "coverageThreshold": 80,
380      "runBeforeCommit": true
381    }
382  }
383}
384```
385 
386### Review Defaults
387```json
388{
389  "development": {
390    "review": {
391      "autoReview": false,
392      "focusAreas": ["bugs", "security", "design"],
393      "severityThreshold": "medium"
394    }
395  }
396}
397```
398 
399## Dependencies
400 
401### Required Plugins
402- **claude-code-system** (^1.0.0): System status and configuration
403 
404### Optional MCP Tools
405- **Sequential Thinking**: Enhances architect and code-reviewer structured reasoning
406- **Serena**: Enables semantic code understanding (70-90% token reduction for code ops)
407- **Context7**: Library documentation access for best practices
408 
409**Graceful Degradation**: All commands work without MCP tools.
410 
411## Best Practices
412 
413### Analysis Workflow
414```bash
415# 1. Start with high-level analysis
416/analyze
417 
418# 2. Deep-dive into specific areas
419/analyze src/auth --semantic --with-thinking
420 
421# 3. Review findings and plan improvements
422```
423 
424### TDD Workflow
425```bash
426# 1. Start TDD mode
427/test tdd
428 
429# 2. Write test first
430# (test-engineer helps generate test cases)
431 
432# 3. Run test (should fail)
433npm test
434 
435# 4. Implement feature
436 
437# 5. Run test (should pass)
438npm test
439 
440# 6. Refactor
441 
442# 7. Repeat
443```
444 
445### Review Workflow
446```bash
447# 1. Self-review before PR
448/review --semantic
449 
450# 2. Fix HIGH priority issues
451/fix review
452 
453# 3. Address MEDIUM priority
454# (make changes manually or with /fix)
455 
456# 4. Re-review to verify
457/review
458 
459# 5. Submit PR when clean
460```
461 
462## Performance Considerations
463 
464### Serena Semantic Analysis
465When Serena MCP is available:
466- **Token Reduction**: 70-90% fewer tokens for code operations
467- **Accuracy**: More precise symbol understanding
468- **Speed**: Faster code navigation and search
469 
470**Enable Serena**:
471 
472Serena is enabled via MCP configuration (not a wrapper command). See [docs/mcp-setup.md](../../docs/mcp-setup.md) for setup instructions.
473 
474### Sequential Thinking
475When Sequential Thinking is available:
476- **Quality**: +20-30% better architectural decisions
477- **Tokens**: +15-30% more tokens (but worth it for complex decisions)
478 
479**Automatic**: Used automatically by architect and code-reviewer when available
480 
481## Troubleshooting
482 
483### /analyze finds no issues
484- Try `--with-thinking` for deeper analysis
485- Use `--semantic` if Serena available
486- Specify focus area: `/analyze src/problem-area`
487 
488### /test can't find test files
489- Verify test framework installed
490- Check test file patterns in config
491- Ensure tests exist in standard locations
492 
493### /fix doesn't find errors
494- Specify error source: `/fix error [file]`
495- Try `/fix review` after running `/review`
496- Check recent command output for errors
497 
498### /review gives too much feedback
499- Set severity threshold in config
500- Focus on specific areas: `/review src/module`
501- Address HIGH priority first, iterate on others
502 
503## Metrics and Quality
504 
505The development plugin tracks:
506- **Code quality**: Issues found, severity distribution
507- **Test coverage**: Percentage covered, gaps identified
508- **Review metrics**: Issues per 1000 lines, time to review
509- **Fix success**: Fixes applied, tests passing after fix
510 
511View with:
512```bash
513/system:status verbose
514/performance
515```
516 
517## Examples
518 
519### Example 1: New Feature with TDD
520```bash
521# Start TDD workflow
522/test tdd
523 
524# Test-engineer generates test cases
525# Implement feature to pass tests
526 
527# Run tests
528npm test
529 
530# Review implementation
531/review src/new-feature
532 
533# Fix any issues
534/fix review
535 
536# Ship it
537/ship --commit
538```
539 
540### Example 2: Bug Investigation
541```bash
542# Analyze problem area
543/analyze src/buggy-module --semantic
544 
545# Review code for bugs
546/review src/buggy-module
547 
548# Fix identified issues
549/fix review
550 
551# Run tests
552npm test
553 
554# Verify fix
555/test src/buggy-module
556```
557 
558### Example 3: Architecture Review
559```bash
560# Get architect input
561/agent architect "Review proposed microservices architecture"
562 
563# Analyze current architecture
564/analyze --with-thinking
565 
566# Identify issues
567/review --systematic
568 
569# Plan improvements based on findings
570```
571 
572## Support
573 
574- **Documentation**: [Development Guide](../../docs/guides/development.md)
575- **Issues**: [GitHub Issues](https://github.com/applied-artificial-intelligence/claude-code-toolkit/issues)
576- **Discussions**: [GitHub Discussions](https://github.com/applied-artificial-intelligence/claude-code-toolkit/discussions)
577 
578## License
579 
580MIT License - see [LICENSE](../../LICENSE) for details.
581 
582---
583 
584**Version**: 1.0.0
585**Category**: Development
586**Commands**: 7 (analyze, docs, fix, git, prepare-review, review, test)
587**Agents**: 3 (architect, test-engineer, code-reviewer)
588**Dependencies**: core (^1.0.0)
589**MCP Tools**: Optional (sequential-thinking, serena, context7)
590