superclaude-kiro 1.0.0

package/dist/steering/superclaude/sc-build.md

@@ -0,0 +1,94 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: build
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/build.md
+
+# /sc:build - Project Building and Packaging
+
+## Triggers
+- Project compilation and packaging requests for different environments
+- Build optimization and artifact generation needs
+- Error debugging during build processes
+- Deployment preparation and artifact packaging requirements
+
+## Usage
+```
+/sc:build [target] [--type dev|prod|test] [--clean] [--optimize] [--verbose]
+```
+
+## Behavioral Flow
+1. **Analyze**: Project structure, build configurations, and dependency manifests
+2. **Validate**: Build environment, dependencies, and required toolchain components
+3. **Execute**: Build process with real-time monitoring and error detection
+4. **Optimize**: Build artifacts, apply optimizations, and minimize bundle sizes
+5. **Package**: Generate deployment artifacts and comprehensive build reports
+
+Key behaviors:
+- Configuration-driven build orchestration with dependency validation
+- Intelligent error analysis with actionable resolution guidance
+- Environment-specific optimization (dev/prod/test configurations)
+- Comprehensive build reporting with timing metrics and artifact analysis
+
+## MCP Integration
+- **Playwright MCP**: Auto-activated for build validation and UI testing during builds
+- **DevOps Engineer Persona**: Activated for build optimization and deployment preparation
+- **Enhanced Capabilities**: Build pipeline integration, performance monitoring, artifact validation
+
+## Tool Coordination
+- **Bash**: Build system execution and process management
+- **Read**: Configuration analysis and manifest inspection
+- **Grep**: Error parsing and build log analysis
+- **Glob**: Artifact discovery and validation
+- **Write**: Build reports and deployment documentation
+
+## Key Patterns
+- **Environment Builds**: dev/prod/test → appropriate configuration and optimization
+- **Error Analysis**: Build failures → diagnostic analysis and resolution guidance
+- **Optimization**: Artifact analysis → size reduction and performance improvements
+- **Validation**: Build verification → quality gates and deployment readiness
+
+## Examples
+
+### Standard Project Build
+```
+/sc:build
+# Builds entire project using default configuration
+# Generates artifacts and comprehensive build report
+```
+
+### Production Optimization Build
+```
+/sc:build --type prod --clean --optimize
+# Clean production build with advanced optimizations
+# Minification, tree-shaking, and deployment preparation
+```
+
+### Targeted Component Build
+```
+/sc:build frontend --verbose
+# Builds specific project component with detailed output
+# Real-time progress monitoring and diagnostic information
+```
+
+### Development Build with Validation
+```
+/sc:build --type dev --validate
+# Development build with Playwright validation
+# UI testing and build verification integration
+```
+
+## Boundaries
+
+**Will:**
+- Execute project build systems using existing configurations
+- Provide comprehensive error analysis and optimization recommendations
+- Generate deployment-ready artifacts with detailed reporting
+
+**Will Not:**
+- Modify build system configuration or create new build scripts
+- Install missing build dependencies or development tools
+- Execute deployment operations beyond artifact preparation

package/dist/steering/superclaude/sc-business-panel.md

@@ -0,0 +1,90 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: business-panel
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/business-panel.md
+
+# /sc:business-panel - Business Panel Analysis System
+
+```yaml
+---
+command: "/sc:business-panel"
+category: "Analysis & Strategic Planning"  
+purpose: "Multi-expert business analysis with adaptive interaction modes"
+wave-enabled: true
+performance-profile: "complex"
+---
+```
+
+## Overview
+
+AI facilitated panel discussion between renowned business thought leaders analyzing documents through their distinct frameworks and methodologies.
+
+## Expert Panel
+
+### Available Experts
+- **Clayton Christensen**: Disruption Theory, Jobs-to-be-Done
+- **Michael Porter**: Competitive Strategy, Five Forces
+- **Peter Drucker**: Management Philosophy, MBO
+- **Seth Godin**: Marketing Innovation, Tribe Building
+- **W. Chan Kim & Renée Mauborgne**: Blue Ocean Strategy
+- **Jim Collins**: Organizational Excellence, Good to Great
+- **Nassim Nicholas Taleb**: Risk Management, Antifragility
+- **Donella Meadows**: Systems Thinking, Leverage Points
+- **Jean-luc Doumont**: Communication Systems, Structured Clarity
+
+## Analysis Modes
+
+### Phase 1: DISCUSSION (Default)
+Collaborative analysis where experts build upon each other's insights through their frameworks.
+
+### Phase 2: DEBATE
+Adversarial analysis activated when experts disagree or for controversial topics.
+
+### Phase 3: SOCRATIC INQUIRY
+Question-driven exploration for deep learning and strategic thinking development.
+
+## Usage
+
+### Basic Usage
+```bash
+/sc:business-panel [document_path_or_content]
+```
+
+### Advanced Options
+```bash
+/sc:business-panel [content] --experts "porter,christensen,meadows"
+/sc:business-panel [content] --mode debate
+/sc:business-panel [content] --focus "competitive-analysis"
+/sc:business-panel [content] --synthesis-only
+```
+
+### Mode Commands
+- `--mode discussion` - Collaborative analysis (default)
+- `--mode debate` - Challenge and stress-test ideas
+- `--mode socratic` - Question-driven exploration
+- `--mode adaptive` - System selects based on content
+
+### Expert Selection
+- `--experts "name1,name2,name3"` - Select specific experts
+- `--focus domain` - Auto-select experts for domain
+- `--all-experts` - Include all 9 experts
+
+### Output Options
+- `--synthesis-only` - Skip detailed analysis, show synthesis
+- `--structured` - Use symbol system for efficiency
+- `--verbose` - Full detailed analysis
+- `--questions` - Focus on strategic questions
+
+## Auto-Persona Activation
+- **Auto-Activates**: Analyzer, Architect, Mentor personas
+- **MCP Integration**: Sequential (primary), Context7 (business patterns)
+- **Tool Orchestration**: Read, Grep, Write, MultiEdit, TodoWrite
+
+## Integration Notes
+- Compatible with all thinking flags (--think, --think-hard, --ultrathink)
+- Supports wave orchestration for comprehensive business analysis
+- Integrates with scribe persona for professional business communication

package/dist/steering/superclaude/sc-cleanup.md

@@ -0,0 +1,93 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: cleanup
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/cleanup.md
+
+# /sc:cleanup - Code and Project Cleanup
+
+## Triggers
+- Code maintenance and technical debt reduction requests
+- Dead code removal and import optimization needs
+- Project structure improvement and organization requirements
+- Codebase hygiene and quality improvement initiatives
+
+## Usage
+```
+/sc:cleanup [target] [--type code|imports|files|all] [--safe|--aggressive] [--interactive]
+```
+
+## Behavioral Flow
+1. **Analyze**: Assess cleanup opportunities and safety considerations across target scope
+2. **Plan**: Choose cleanup approach and activate relevant personas for domain expertise
+3. **Execute**: Apply systematic cleanup with intelligent dead code detection and removal
+4. **Validate**: Ensure no functionality loss through testing and safety verification
+5. **Report**: Generate cleanup summary with recommendations for ongoing maintenance
+
+Key behaviors:
+- Multi-persona coordination (architect, quality, security) based on cleanup type
+- Framework-specific cleanup patterns via Context7 MCP integration
+- Systematic analysis via Sequential MCP for complex cleanup operations
+- Safety-first approach with backup and rollback capabilities
+
+## MCP Integration
+- **Sequential MCP**: Auto-activated for complex multi-step cleanup analysis and planning
+- **Context7 MCP**: Framework-specific cleanup patterns and best practices
+- **Persona Coordination**: Architect (structure), Quality (debt), Security (credentials)
+
+## Tool Coordination
+- **Read/Grep/Glob**: Code analysis and pattern detection for cleanup opportunities
+- **Edit/MultiEdit**: Safe code modification and structure optimization
+- **TodoWrite**: Progress tracking for complex multi-file cleanup operations
+- **Task**: Delegation for large-scale cleanup workflows requiring systematic coordination
+
+## Key Patterns
+- **Dead Code Detection**: Usage analysis → safe removal with dependency validation
+- **Import Optimization**: Dependency analysis → unused import removal and organization
+- **Structure Cleanup**: Architectural analysis → file organization and modular improvements
+- **Safety Validation**: Pre/during/post checks → preserve functionality throughout cleanup
+
+## Examples
+
+### Safe Code Cleanup
+```
+/sc:cleanup src/ --type code --safe
+# Conservative cleanup with automatic safety validation
+# Removes dead code while preserving all functionality
+```
+
+### Import Optimization
+```
+/sc:cleanup --type imports --preview
+# Analyzes and shows unused import cleanup without execution
+# Framework-aware optimization via Context7 patterns
+```
+
+### Comprehensive Project Cleanup
+```
+/sc:cleanup --type all --interactive
+# Multi-domain cleanup with user guidance for complex decisions
+# Activates all personas for comprehensive analysis
+```
+
+### Framework-Specific Cleanup
+```
+/sc:cleanup components/ --aggressive
+# Thorough cleanup with Context7 framework patterns
+# Sequential analysis for complex dependency management
+```
+
+## Boundaries
+
+**Will:**
+- Systematically clean code, remove dead code, and optimize project structure
+- Provide comprehensive safety validation with backup and rollback capabilities
+- Apply intelligent cleanup algorithms with framework-specific pattern recognition
+
+**Will Not:**
+- Remove code without thorough safety analysis and validation
+- Override project-specific cleanup exclusions or architectural constraints
+- Apply cleanup operations that compromise functionality or introduce bugs

package/dist/steering/superclaude/sc-design.md

@@ -0,0 +1,88 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: design
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/design.md
+
+# /sc:design - System and Component Design
+
+## Triggers
+- Architecture planning and system design requests
+- API specification and interface design needs
+- Component design and technical specification requirements
+- Database schema and data model design requests
+
+## Usage
+```
+/sc:design [target] [--type architecture|api|component|database] [--format diagram|spec|code]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine target requirements and existing system context
+2. **Plan**: Define design approach and structure based on type and format
+3. **Design**: Create comprehensive specifications with industry best practices
+4. **Validate**: Ensure design meets requirements and maintainability standards
+5. **Document**: Generate clear design documentation with diagrams and specifications
+
+Key behaviors:
+- Requirements-driven design approach with scalability considerations
+- Industry best practices integration for maintainable solutions
+- Multi-format output (diagrams, specifications, code) based on needs
+- Validation against existing system architecture and constraints
+
+## Tool Coordination
+- **Read**: Requirements analysis and existing system examination
+- **Grep/Glob**: Pattern analysis and system structure investigation
+- **Write**: Design documentation and specification generation
+- **Bash**: External design tool integration when needed
+
+## Key Patterns
+- **Architecture Design**: Requirements → system structure → scalability planning
+- **API Design**: Interface specification → RESTful/GraphQL patterns → documentation
+- **Component Design**: Functional requirements → interface design → implementation guidance
+- **Database Design**: Data requirements → schema design → relationship modeling
+
+## Examples
+
+### System Architecture Design
+```
+/sc:design user-management-system --type architecture --format diagram
+# Creates comprehensive system architecture with component relationships
+# Includes scalability considerations and best practices
+```
+
+### API Specification Design
+```
+/sc:design payment-api --type api --format spec
+# Generates detailed API specification with endpoints and data models
+# Follows RESTful design principles and industry standards
+```
+
+### Component Interface Design
+```
+/sc:design notification-service --type component --format code
+# Designs component interfaces with clear contracts and dependencies
+# Provides implementation guidance and integration patterns
+```
+
+### Database Schema Design
+```
+/sc:design e-commerce-db --type database --format diagram
+# Creates database schema with entity relationships and constraints
+# Includes normalization and performance considerations
+```
+
+## Boundaries
+
+**Will:**
+- Create comprehensive design specifications with industry best practices
+- Generate multiple format outputs (diagrams, specs, code) based on requirements
+- Validate designs against maintainability and scalability standards
+
+**Will Not:**
+- Generate actual implementation code (use /sc:implement for implementation)
+- Modify existing system architecture without explicit design approval
+- Create designs that violate established architectural constraints

package/dist/steering/superclaude/sc-document.md

@@ -0,0 +1,88 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: document
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/document.md
+
+# /sc:document - Focused Documentation Generation
+
+## Triggers
+- Documentation requests for specific components, functions, or features
+- API documentation and reference material generation needs
+- Code comment and inline documentation requirements
+- User guide and technical documentation creation requests
+
+## Usage
+```
+/sc:document [target] [--type inline|external|api|guide] [--style brief|detailed]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine target component structure, interfaces, and functionality
+2. **Identify**: Determine documentation requirements and target audience context
+3. **Generate**: Create appropriate documentation content based on type and style
+4. **Format**: Apply consistent structure and organizational patterns
+5. **Integrate**: Ensure compatibility with existing project documentation ecosystem
+
+Key behaviors:
+- Code structure analysis with API extraction and usage pattern identification
+- Multi-format documentation generation (inline, external, API reference, guides)
+- Consistent formatting and cross-reference integration
+- Language-specific documentation patterns and conventions
+
+## Tool Coordination
+- **Read**: Component analysis and existing documentation review
+- **Grep**: Reference extraction and pattern identification
+- **Write**: Documentation file creation with proper formatting
+- **Glob**: Multi-file documentation projects and organization
+
+## Key Patterns
+- **Inline Documentation**: Code analysis → JSDoc/docstring generation → inline comments
+- **API Documentation**: Interface extraction → reference material → usage examples
+- **User Guides**: Feature analysis → tutorial content → implementation guidance
+- **External Docs**: Component overview → detailed specifications → integration instructions
+
+## Examples
+
+### Inline Code Documentation
+```
+/sc:document src/auth/login.js --type inline
+# Generates JSDoc comments with parameter and return descriptions
+# Adds comprehensive inline documentation for functions and classes
+```
+
+### API Reference Generation
+```
+/sc:document src/api --type api --style detailed
+# Creates comprehensive API documentation with endpoints and schemas
+# Generates usage examples and integration guidelines
+```
+
+### User Guide Creation
+```
+/sc:document payment-module --type guide --style brief
+# Creates user-focused documentation with practical examples
+# Focuses on implementation patterns and common use cases
+```
+
+### Component Documentation
+```
+/sc:document components/ --type external
+# Generates external documentation files for component library
+# Includes props, usage examples, and integration patterns
+```
+
+## Boundaries
+
+**Will:**
+- Generate focused documentation for specific components and features
+- Create multiple documentation formats based on target audience needs
+- Integrate with existing documentation ecosystems and maintain consistency
+
+**Will Not:**
+- Generate documentation without proper code analysis and context understanding
+- Override existing documentation standards or project-specific conventions
+- Create documentation that exposes sensitive implementation details

package/dist/steering/superclaude/sc-estimate.md

@@ -0,0 +1,86 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: estimate
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/estimate.md
+
+# /sc:estimate - Development Estimation
+
+## Triggers
+- Development planning requiring time, effort, or complexity estimates
+- Project scoping and resource allocation decisions
+- Feature breakdown needing systematic estimation methodology
+- Risk assessment and confidence interval analysis requirements
+
+## Usage
+```
+/sc:estimate [target] [--type time|effort|complexity] [--unit hours|days|weeks] [--breakdown]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine scope, complexity factors, dependencies, and framework patterns
+2. **Calculate**: Apply estimation methodology with historical benchmarks and complexity scoring
+3. **Validate**: Cross-reference estimates with project patterns and domain expertise
+4. **Present**: Provide detailed breakdown with confidence intervals and risk assessment
+5. **Track**: Document estimation accuracy for continuous methodology improvement
+
+Key behaviors:
+- Multi-persona coordination (architect, performance, project-manager) based on estimation scope
+- Sequential MCP integration for systematic analysis and complexity assessment
+- Context7 MCP integration for framework-specific patterns and historical benchmarks
+- Intelligent breakdown analysis with confidence intervals and risk factors
+
+## MCP Integration
+- **Sequential MCP**: Complex multi-step estimation analysis and systematic complexity assessment
+- **Context7 MCP**: Framework-specific estimation patterns and historical benchmark data
+- **Persona Coordination**: Architect (design complexity), Performance (optimization effort), Project Manager (timeline)
+
+## Tool Coordination
+- **Read/Grep/Glob**: Codebase analysis for complexity assessment and scope evaluation
+- **TodoWrite**: Estimation breakdown and progress tracking for complex estimation workflows
+- **Task**: Advanced delegation for multi-domain estimation requiring systematic coordination
+- **Bash**: Project analysis and dependency evaluation for accurate complexity scoring
+
+## Key Patterns
+- **Scope Analysis**: Project requirements → complexity factors → framework patterns → risk assessment
+- **Estimation Methodology**: Time-based → Effort-based → Complexity-based → Cost-based approaches
+- **Multi-Domain Assessment**: Architecture complexity → Performance requirements → Project timeline
+- **Validation Framework**: Historical benchmarks → cross-validation → confidence intervals → accuracy tracking
+
+## Examples
+
+### Feature Development Estimation
+```
+/sc:estimate "user authentication system" --type time --unit days --breakdown
+# Systematic analysis: Database design (2 days) + Backend API (3 days) + Frontend UI (2 days) + Testing (1 day)
+# Total: 8 days with 85% confidence interval
+```
+
+### Project Complexity Assessment
+```
+/sc:estimate "migrate monolith to microservices" --type complexity --breakdown
+# Architecture complexity analysis with risk factors and dependency mapping
+# Multi-persona coordination for comprehensive assessment
+```
+
+### Performance Optimization Effort
+```
+/sc:estimate "optimize application performance" --type effort --unit hours
+# Performance persona analysis with benchmark comparisons
+# Effort breakdown by optimization category and expected impact
+```
+
+## Boundaries
+
+**Will:**
+- Provide systematic development estimates with confidence intervals and risk assessment
+- Apply multi-persona coordination for comprehensive complexity analysis
+- Generate detailed breakdown analysis with historical benchmark comparisons
+
+**Will Not:**
+- Guarantee estimate accuracy without proper scope analysis and validation
+- Provide estimates without appropriate domain expertise and complexity assessment
+- Override historical benchmarks without clear justification and analysis

package/dist/steering/superclaude/sc-explain.md

@@ -0,0 +1,92 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: explain
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/explain.md
+
+# /sc:explain - Code and Concept Explanation
+
+## Triggers
+- Code understanding and documentation requests for complex functionality
+- System behavior explanation needs for architectural components
+- Educational content generation for knowledge transfer
+- Framework-specific concept clarification requirements
+
+## Usage
+```
+/sc:explain [target] [--level basic|intermediate|advanced] [--format text|examples|interactive] [--context domain]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine target code, concept, or system for comprehensive understanding
+2. **Assess**: Determine audience level and appropriate explanation depth and format
+3. **Structure**: Plan explanation sequence with progressive complexity and logical flow
+4. **Generate**: Create clear explanations with examples, diagrams, and interactive elements
+5. **Validate**: Verify explanation accuracy and educational effectiveness
+
+Key behaviors:
+- Multi-persona coordination for domain expertise (educator, architect, security)
+- Framework-specific explanations via Context7 integration
+- Systematic analysis via Sequential MCP for complex concept breakdown
+- Adaptive explanation depth based on audience and complexity
+
+## MCP Integration
+- **Sequential MCP**: Auto-activated for complex multi-component analysis and structured reasoning
+- **Context7 MCP**: Framework documentation and official pattern explanations
+- **Persona Coordination**: Educator (learning), Architect (systems), Security (practices)
+
+## Tool Coordination
+- **Read/Grep/Glob**: Code analysis and pattern identification for explanation content
+- **TodoWrite**: Progress tracking for complex multi-part explanations
+- **Task**: Delegation for comprehensive explanation workflows requiring systematic breakdown
+
+## Key Patterns
+- **Progressive Learning**: Basic concepts → intermediate details → advanced implementation
+- **Framework Integration**: Context7 documentation → accurate official patterns and practices
+- **Multi-Domain Analysis**: Technical accuracy + educational clarity + security awareness
+- **Interactive Explanation**: Static content → examples → interactive exploration
+
+## Examples
+
+### Basic Code Explanation
+```
+/sc:explain authentication.js --level basic
+# Clear explanation with practical examples for beginners
+# Educator persona provides learning-optimized structure
+```
+
+### Framework Concept Explanation
+```
+/sc:explain react-hooks --level intermediate --context react
+# Context7 integration for official React documentation patterns
+# Structured explanation with progressive complexity
+```
+
+### System Architecture Explanation
+```
+/sc:explain microservices-system --level advanced --format interactive
+# Architect persona explains system design and patterns
+# Interactive exploration with Sequential analysis breakdown
+```
+
+### Security Concept Explanation
+```
+/sc:explain jwt-authentication --context security --level basic
+# Security persona explains authentication concepts and best practices
+# Framework-agnostic security principles with practical examples
+```
+
+## Boundaries
+
+**Will:**
+- Provide clear, comprehensive explanations with educational clarity
+- Auto-activate relevant personas for domain expertise and accurate analysis
+- Generate framework-specific explanations with official documentation integration
+
+**Will Not:**
+- Generate explanations without thorough analysis and accuracy verification
+- Override project-specific documentation standards or reveal sensitive details
+- Bypass established explanation validation or educational quality requirements