Skip to content

Commit 7d679e8

Browse files
ncolesummersncolesummers
authored
Merge pull request #8 from ncolesummers/feature/devops-claude
Feature/devops claude
2 parents 1e27ddf + 5442221 commit 7d679e8

File tree

59 files changed

+4926
-1686
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

59 files changed

+4926
-1686
lines changed

‎.claude/commands/README.md‎

Lines changed: 195 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,195 @@
1+
# Role-Based Slash Commands for Claude Code
2+
3+
This directory contains custom slash commands that transform Claude into specialized expert roles for multi-perspective software development analysis.
4+
5+
## Quick Start
6+
7+
### Analyze a Task
8+
```bash
9+
/project:workflows:analyze-task "Implement OAuth2 authentication with role-based permissions"
10+
```
11+
12+
### Single Role Analysis
13+
```bash
14+
/project:roles:senior-frontend-architect "Review the new dashboard component architecture"
15+
```
16+
17+
### Sequential Expert Chain
18+
```bash
19+
/project:chains:feature-development "Create a real-time notification system"
20+
```
21+
22+
### Parallel Expert Analysis
23+
```bash
24+
/project:parallel:code-review-team "PR #123 - Authentication refactor"
25+
```
26+
27+
## Command Categories
28+
29+
### 🎭 Individual Roles (`/project:roles:`)
30+
Specialized expert perspectives for focused analysis:
31+
- `product-manager` - Business requirements and strategy
32+
- `senior-frontend-architect` - Technical architecture and design
33+
- `typescript-quality-engineer` - Code quality and type safety
34+
- `senior-sdet` - Testing strategy and quality assurance
35+
- `cybersecurity-engineer` - Security assessment and compliance
36+
- `devops-engineer` - Infrastructure and deployment
37+
- `ui-ux-design-engineer` - User experience and accessibility
38+
- `open-source-maintainer` - Community and sustainability
39+
40+
### 🔗 Sequential Chains (`/project:chains:`)
41+
Multi-role workflows that build upon each phase:
42+
- `feature-development` - Complete feature development lifecycle
43+
- `bug-fix-optimization` - Comprehensive bug analysis and resolution
44+
- `security-review` - Multi-layered security assessment
45+
46+
### ⚡ Parallel Analysis (`/project:parallel:`)
47+
Simultaneous expert perspectives with synthesis:
48+
- `code-review-team` - Multi-expert code review
49+
- `feature-planning-team` - Comprehensive feature planning
50+
- `performance-team` - Performance optimization analysis
51+
52+
### 🛠️ Workflow Utilities (`/project:workflows:`)
53+
Supporting tools for complex workflows:
54+
- `analyze-task` - Determine optimal workflow strategy
55+
- `handoff-context` - Preserve context between roles
56+
- `synthesize-perspectives` - Unify multi-role insights
57+
58+
### ⚡ Quick Actions (`/project:quick:`)
59+
Rapid, focused expert responses:
60+
- `review-pr` - Fast TypeScript-focused PR review
61+
- `fix-bug` - Quick bug analysis and resolution
62+
- `optimize-performance` - Immediate performance improvements
63+
- `security-check` - Rapid security assessment
64+
65+
## Usage Patterns
66+
67+
### Pattern 1: Task Complexity Analysis
68+
Start with complexity analysis to choose the right approach:
69+
```bash
70+
/project:workflows:analyze-task "Your complex development task"
71+
# Follow the recommended workflow from the analysis
72+
```
73+
74+
### Pattern 2: Single Expert Consultation
75+
For focused, domain-specific analysis:
76+
```bash
77+
/project:roles:cybersecurity-engineer "Review authentication implementation"
78+
```
79+
80+
### Pattern 3: Sequential Expert Chain
81+
For comprehensive feature development:
82+
```bash
83+
/project:chains:feature-development "Build user analytics dashboard"
84+
# Automatically progresses through Product → Architecture → Quality → Testing
85+
```
86+
87+
### Pattern 4: Parallel Expert Team
88+
For complex decisions requiring multiple perspectives:
89+
```bash
90+
/project:parallel:code-review-team "Major refactoring PR"
91+
# Gets simultaneous input from Architecture, Quality, and Security experts
92+
```
93+
94+
### Pattern 5: Context Handoff
95+
For manual role transitions:
96+
```bash
97+
/project:roles:product-manager "Define user requirements"
98+
# Then use the output as input to:
99+
/project:workflows:handoff-context "[Product Manager's analysis]"
100+
# Finally:
101+
/project:roles:senior-frontend-architect "[Handoff context + original task]"
102+
```
103+
104+
## Command Composition Examples
105+
106+
### Example 1: Feature Development
107+
```bash
108+
# Step 1: Analyze complexity
109+
/project:workflows:analyze-task "Real-time collaboration features"
110+
111+
# Step 2: Follow recommended approach (e.g., sequential chain)
112+
/project:chains:feature-development "Real-time collaboration features"
113+
114+
# Step 3: If conflicts arise, synthesize
115+
/project:workflows:synthesize-perspectives "[Chain output]"
116+
```
117+
118+
### Example 2: Bug Investigation
119+
```bash
120+
# Quick assessment
121+
/project:quick:fix-bug "Memory leak in dashboard component"
122+
123+
# If complex, escalate to full analysis
124+
/project:chains:bug-fix-optimization "Memory leak in dashboard component"
125+
```
126+
127+
### Example 3: Code Review
128+
```bash
129+
# Quick review
130+
/project:quick:review-pr "Authentication service changes"
131+
132+
# For critical changes, get team perspective
133+
/project:parallel:code-review-team "Authentication service changes"
134+
```
135+
136+
## Best Practices
137+
138+
1. **Start with Analysis**: Use `/project:workflows:analyze-task` for complex or unfamiliar tasks
139+
2. **Choose Appropriate Scope**: Single role for focused issues, chains for comprehensive development, parallel for critical decisions
140+
3. **Preserve Context**: Use handoff commands when manually transitioning between roles
141+
4. **Synthesize Conflicts**: Use synthesis commands when parallel analyses conflict
142+
5. **Document Decisions**: Keep role outputs for future reference and team alignment
143+
144+
## Integration with Development Workflow
145+
146+
### Git Integration
147+
```bash
148+
# Before starting work
149+
/project:workflows:analyze-task "$(git show --name-only HEAD)"
150+
151+
# During development
152+
/project:quick:review-pr "$(git diff --name-only main...HEAD)"
153+
154+
# Before merging
155+
/project:parallel:code-review-team "$(git log --oneline main...HEAD)"
156+
```
157+
158+
### CI/CD Integration
159+
Use commands in pull request templates or automated checks:
160+
```markdown
161+
## Pre-merge Checklist
162+
- [ ] `/project:quick:security-check` completed
163+
- [ ] `/project:quick:optimize-performance` reviewed
164+
- [ ] `/project:parallel:code-review-team` approved
165+
```
166+
167+
## Troubleshooting
168+
169+
### Command Not Found
170+
- Verify `.claude/commands/` directory structure
171+
- Check file naming matches command structure
172+
- Ensure files are in the correct subdirectories
173+
174+
### Poor Role Performance
175+
- Provide more specific context in arguments
176+
- Use handoff commands to preserve context between roles
177+
- Try analyze-task first for complex scenarios
178+
179+
### Conflicting Recommendations
180+
- Use `/project:workflows:synthesize-perspectives`
181+
- Review individual role constraints and assumptions
182+
- Consider parallel analysis for critical decisions
183+
184+
## Contributing
185+
186+
To add new roles or workflows:
187+
1. Follow existing file naming patterns
188+
2. Include clear role definitions and responsibilities
189+
3. Use `$ARGUMENTS` for dynamic input
190+
4. Provide structured output templates
191+
5. Test with various input scenarios
192+
193+
---
194+
195+
**Next Steps**: Run `/project:test-setup "Initial validation"` to verify your command setup.

‎.claude/commands/chains/bug-fix-optimization.md‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
# Bug Fix & Optimization Chain Workflow
2+
3+
I need you to help analyze and fix a bug or performance issue through multiple expert perspectives sequentially.
4+
5+
**Bug/Issue**: $ARGUMENTS
6+
7+
## Phase 1: TypeScript Quality Engineer Perspective
8+
First, as a TypeScript Quality Engineer:
9+
- Analyze the root cause of the issue
10+
- Identify code quality problems or anti-patterns
11+
- Assess type safety and error handling
12+
- Review related code for similar issues
13+
- Recommend immediate fixes and preventive measures
14+
15+
## Phase 2: Senior Frontend Architect Perspective
16+
Next, as a Senior Frontend Architect:
17+
- Evaluate architectural implications of the fix
18+
- Consider impact on existing component structure
19+
- Assess performance implications
20+
- Recommend architectural improvements
21+
- Plan for scalability and maintainability
22+
23+
## Phase 3: Senior SDET Perspective
24+
Then, as a Senior SDET:
25+
- Design tests to prevent regression
26+
- Create comprehensive test cases for the fix
27+
- Plan integration and E2E test coverage
28+
- Establish monitoring and alerting for similar issues
29+
- Recommend quality gates to catch future occurrences
30+
31+
## Phase 4: Cybersecurity Engineer Perspective
32+
Finally, as a Cybersecurity Engineer:
33+
- Assess security implications of the bug and fix
34+
- Identify potential security vulnerabilities
35+
- Recommend security hardening measures
36+
- Plan security testing and validation
37+
- Consider compliance and audit requirements
38+
39+
**Instructions**: After each phase, document key findings and recommendations. Provide a final comprehensive fix plan with implementation steps, testing strategy, and prevention measures.

‎.claude/commands/chains/feature-development.md‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
# Feature Development Chain Workflow
2+
3+
I need you to help develop a new feature by working through multiple specialized perspectives sequentially.
4+
5+
**Feature/Task**: $ARGUMENTS
6+
7+
## Phase 1: Product Manager Perspective
8+
First, adopt the role of a Product Manager and:
9+
- Define clear user stories and acceptance criteria
10+
- Identify success metrics and KPIs
11+
- Outline MVP vs full feature scope
12+
- Consider business value and prioritization
13+
- Assess market positioning and competitive advantage
14+
15+
## Phase 2: Senior Frontend Architect Perspective
16+
Next, as a Senior Frontend Architect:
17+
- Design the technical architecture
18+
- Define component structure and reusability patterns
19+
- Plan state management approach
20+
- Identify integration points with existing systems
21+
- Consider performance and scalability implications
22+
23+
## Phase 3: TypeScript Quality Engineer Perspective
24+
Then, as a TypeScript Quality Engineer:
25+
- Define type interfaces and contracts
26+
- Plan error handling strategies
27+
- Ensure type safety across components
28+
- Recommend coding standards and patterns
29+
- Design validation and data flow patterns
30+
31+
## Phase 4: Senior SDET Perspective
32+
Finally, as a Senior SDET:
33+
- Create comprehensive test strategy
34+
- Define test cases for each component
35+
- Plan E2E testing approach
36+
- Establish quality gates and CI/CD integration
37+
- Design accessibility and cross-browser testing
38+
39+
**Instructions**: After each phase, explicitly document key decisions and constraints that should inform the next phase. Provide a final synthesis with actionable next steps and implementation roadmap.

‎.claude/commands/chains/security-review.md‎

Lines changed: 39 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,39 @@
1+
# Security Review Chain Workflow
2+
3+
I need you to conduct a comprehensive security review through multiple expert perspectives sequentially.
4+
5+
**Code/System to Review**: $ARGUMENTS
6+
7+
## Phase 1: Cybersecurity Engineer Perspective
8+
First, as a Cybersecurity Engineer:
9+
- Conduct OWASP Top 10 vulnerability assessment
10+
- Analyze authentication and authorization patterns
11+
- Review data protection and privacy compliance
12+
- Assess input validation and injection prevention
13+
- Identify security monitoring and logging gaps
14+
15+
## Phase 2: DevOps Engineer Perspective
16+
Next, as a DevOps Engineer:
17+
- Review deployment security and CI/CD pipeline
18+
- Assess infrastructure security configurations
19+
- Evaluate secrets management and environment security
20+
- Review monitoring and incident response capabilities
21+
- Consider compliance and audit trail requirements
22+
23+
## Phase 3: Senior Frontend Architect Perspective
24+
Then, as a Senior Frontend Architect:
25+
- Analyze client-side security patterns
26+
- Review state management for sensitive data
27+
- Assess API integration security
28+
- Evaluate third-party dependency security
29+
- Consider browser security and CSP implementation
30+
31+
## Phase 4: TypeScript Quality Engineer Perspective
32+
Finally, as a TypeScript Quality Engineer:
33+
- Review type safety for security-critical code
34+
- Analyze error handling and information disclosure
35+
- Assess input validation and sanitization
36+
- Review code quality for security implications
37+
- Recommend secure coding patterns
38+
39+
**Instructions**: After each phase, document security findings and risk assessments. Provide a final comprehensive security report with prioritized recommendations, remediation steps, and security improvement roadmap.

‎.claude/commands/parallel/code-review-team.md‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
# Multi-Perspective Code Review Team
2+
3+
Analyze the following code changes from three simultaneous expert perspectives:
4+
5+
**Code/PR to Review**: $ARGUMENTS
6+
7+
## Parallel Analysis Required:
8+
9+
### Perspective 1: Senior Frontend Architect
10+
- Architecture patterns and design decisions
11+
- Component structure and modularity
12+
- Performance implications and optimization opportunities
13+
- Scalability concerns and maintainability
14+
- Integration patterns and data flow
15+
16+
### Perspective 2: TypeScript Quality Engineer
17+
- Type safety and contract definitions
18+
- Code quality and standards adherence
19+
- Error handling and validation patterns
20+
- Best practices and anti-pattern identification
21+
- Build and tooling implications
22+
23+
### Perspective 3: Cybersecurity Engineer
24+
- Security vulnerabilities and risk assessment
25+
- Authentication/authorization pattern security
26+
- Data protection and privacy compliance
27+
- OWASP compliance and security best practices
28+
- Input validation and injection prevention
29+
30+
## Synthesis Instructions:
31+
After analyzing from all three perspectives:
32+
1. **Alignment Areas**: Identify where all perspectives agree
33+
2. **Conflicting Recommendations**: Highlight disagreements and propose resolutions
34+
3. **Prioritized Feedback**: Provide unified, prioritized recommendations
35+
4. **Specific Improvements**: Suggest concrete code changes with examples
36+
5. **Risk Assessment**: Overall risk level and mitigation strategies
37+
38+
Format the output as a comprehensive code review with sections for each perspective, followed by synthesized recommendations and action items.

‎.claude/commands/parallel/feature-planning-team.md‎

Lines changed: 38 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,38 @@
1+
# Multi-Perspective Feature Planning Team
2+
3+
Analyze the following feature request from three simultaneous expert perspectives:
4+
5+
**Feature to Plan**: $ARGUMENTS
6+
7+
## Parallel Analysis Required:
8+
9+
### Perspective 1: Product Manager
10+
- Business value and user impact assessment
11+
- Market positioning and competitive analysis
12+
- Success metrics and KPI definition
13+
- MVP vs full feature scope planning
14+
- Stakeholder alignment and communication strategy
15+
16+
### Perspective 2: Senior Frontend Architect
17+
- Technical feasibility and architecture design
18+
- Component structure and reusability patterns
19+
- Performance and scalability considerations
20+
- Integration complexity with existing systems
21+
- Technology stack and tool requirements
22+
23+
### Perspective 3: Senior SDET
24+
- Testability and quality assurance strategy
25+
- Test automation framework requirements
26+
- Quality gates and acceptance criteria
27+
- Risk assessment and mitigation planning
28+
- CI/CD integration and deployment strategy
29+
30+
## Synthesis Instructions:
31+
After analyzing from all three perspectives:
32+
1. **Feasibility Assessment**: Overall technical and business feasibility
33+
2. **Resource Requirements**: Development, testing, and infrastructure needs
34+
3. **Risk Matrix**: Identified risks with probability and impact assessment
35+
4. **Implementation Roadmap**: Phased approach with milestones and dependencies
36+
5. **Success Criteria**: Measurable outcomes and acceptance criteria
37+
38+
Format the output as a comprehensive feature planning document with executive summary, detailed analysis from each perspective, and unified implementation plan.

0 commit comments

Comments
 (0)