superclaude-kiro 1.0.0

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

@@ -0,0 +1,80 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: git
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/git.md
+
+# /sc:git - Git Operations
+
+## Triggers
+- Git repository operations: status, add, commit, push, pull, branch
+- Need for intelligent commit message generation
+- Repository workflow optimization requests
+- Branch management and merge operations
+
+## Usage
+```
+/sc:git [operation] [args] [--smart-commit] [--interactive]
+```
+
+## Behavioral Flow
+1. **Analyze**: Check repository state and working directory changes
+2. **Validate**: Ensure operation is appropriate for current Git context
+3. **Execute**: Run Git command with intelligent automation
+4. **Optimize**: Apply smart commit messages and workflow patterns
+5. **Report**: Provide status and next steps guidance
+
+Key behaviors:
+- Generate conventional commit messages based on change analysis
+- Apply consistent branch naming conventions
+- Handle merge conflicts with guided resolution
+- Provide clear status summaries and workflow recommendations
+
+## Tool Coordination
+- **Bash**: Git command execution and repository operations
+- **Read**: Repository state analysis and configuration review
+- **Grep**: Log parsing and status analysis
+- **Write**: Commit message generation and documentation
+
+## Key Patterns
+- **Smart Commits**: Analyze changes → generate conventional commit message
+- **Status Analysis**: Repository state → actionable recommendations
+- **Branch Strategy**: Consistent naming and workflow enforcement
+- **Error Recovery**: Conflict resolution and state restoration guidance
+
+## Examples
+
+### Smart Status Analysis
+```
+/sc:git status
+# Analyzes repository state with change summary
+# Provides next steps and workflow recommendations
+```
+
+### Intelligent Commit
+```
+/sc:git commit --smart-commit
+# Generates conventional commit message from change analysis
+# Applies best practices and consistent formatting
+```
+
+### Interactive Operations
+```
+/sc:git merge feature-branch --interactive
+# Guided merge with conflict resolution assistance
+```
+
+## Boundaries
+
+**Will:**
+- Execute Git operations with intelligent automation
+- Generate conventional commit messages from change analysis
+- Provide workflow optimization and best practice guidance
+
+**Will Not:**
+- Modify repository configuration without explicit authorization
+- Execute destructive operations without confirmation
+- Handle complex merges requiring manual intervention

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

@@ -0,0 +1,148 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: help
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/help.md
+
+# /sc:help - Command Reference Documentation
+
+## Triggers
+- Command discovery and reference lookup requests
+- Framework exploration and capability understanding needs
+- Documentation requests for available SuperClaude commands
+
+## Behavioral Flow
+1. **Display**: Present complete command list with descriptions
+2. **Complete**: End interaction after displaying information
+
+Key behaviors:
+- Information display only - no execution or implementation
+- Reference documentation mode without action triggers
+
+Here is a complete list of all available SuperClaude (`/sc`) commands.
+
+| Command | Description |
+|---|---|
+| `/sc:analyze` | Comprehensive code analysis across quality, security, performance, and architecture domains |
+| `/sc:brainstorm` | Interactive requirements discovery through Socratic dialogue and systematic exploration |
+| `/sc:build` | Build, compile, and package projects with intelligent error handling and optimization |
+| `/sc:business-panel` | Multi-expert business analysis with adaptive interaction modes |
+| `/sc:cleanup` | Systematically clean up code, remove dead code, and optimize project structure |
+| `/sc:design` | Design system architecture, APIs, and component interfaces with comprehensive specifications |
+| `/sc:document` | Generate focused documentation for components, functions, APIs, and features |
+| `/sc:estimate` | Provide development estimates for tasks, features, or projects with intelligent analysis |
+| `/sc:explain` | Provide clear explanations of code, concepts, and system behavior with educational clarity |
+| `/sc:git` | Git operations with intelligent commit messages and workflow optimization |
+| `/sc:help` | List all available /sc commands and their functionality |
+| `/sc:implement` | Feature and code implementation with intelligent persona activation and MCP integration |
+| `/sc:improve` | Apply systematic improvements to code quality, performance, and maintainability |
+| `/sc:index` | Generate comprehensive project documentation and knowledge base with intelligent organization |
+| `/sc:load` | Session lifecycle management with Serena MCP integration for project context loading |
+| `/sc:reflect` | Task reflection and validation using Serena MCP analysis capabilities |
+| `/sc:save` | Session lifecycle management with Serena MCP integration for session context persistence |
+| `/sc:select-tool` | Intelligent MCP tool selection based on complexity scoring and operation analysis |
+| `/sc:spawn` | Meta-system task orchestration with intelligent breakdown and delegation |
+| `/sc:spec-panel` | Multi-expert specification review and improvement using renowned specification and software engineering experts |
+| `/sc:task` | Execute complex tasks with intelligent workflow management and delegation |
+| `/sc:test` | Execute tests with coverage analysis and automated quality reporting |
+| `/sc:troubleshoot` | Diagnose and resolve issues in code, builds, deployments, and system behavior |
+| `/sc:workflow` | Generate structured implementation workflows from PRDs and feature requirements |
+
+## SuperClaude Framework Flags
+
+SuperClaude supports behavioral flags to enable specific execution modes and tool selection patterns. Use these flags with any `/sc` command to customize behavior.
+
+### Mode Activation Flags
+
+| Flag | Trigger | Behavior |
+|------|---------|----------|
+| `--brainstorm` | Vague project requests, exploration keywords | Activate collaborative discovery mindset, ask probing questions |
+| `--introspect` | Self-analysis requests, error recovery | Expose thinking process with transparency markers |
+| `--task-manage` | Multi-step operations (>3 steps) | Orchestrate through delegation, systematic organization |
+| `--orchestrate` | Multi-tool operations, parallel execution | Optimize tool selection matrix, enable parallel thinking |
+| `--token-efficient` | Context usage >75%, large-scale operations | Symbol-enhanced communication, 30-50% token reduction |
+
+### MCP Server Flags
+
+| Flag | Trigger | Behavior |
+|------|---------|----------|
+| `--c7` / `--context7` | Library imports, framework questions | Enable Context7 for curated documentation lookup |
+| `--seq` / `--sequential` | Complex debugging, system design | Enable Sequential for structured multi-step reasoning |
+| `--magic` | UI component requests (/ui, /21) | Enable Magic for modern UI generation from 21st.dev |
+| `--morph` / `--morphllm` | Bulk code transformations | Enable Morphllm for efficient multi-file pattern application |
+| `--serena` | Symbol operations, project memory | Enable Serena for semantic understanding and session persistence |
+| `--play` / `--playwright` | Browser testing, E2E scenarios | Enable Playwright for real browser automation and testing |
+| `--all-mcp` | Maximum complexity scenarios | Enable all MCP servers for comprehensive capability |
+| `--no-mcp` | Native-only execution needs | Disable all MCP servers, use native tools |
+
+### Analysis Depth Flags
+
+| Flag | Trigger | Behavior |
+|------|---------|----------|
+| `--think` | Multi-component analysis needs | Standard structured analysis (~4K tokens), enables Sequential |
+| `--think-hard` | Architectural analysis, system-wide dependencies | Deep analysis (~10K tokens), enables Sequential + Context7 |
+| `--ultrathink` | Critical system redesign, legacy modernization | Maximum depth analysis (~32K tokens), enables all MCP servers |
+
+### Execution Control Flags
+
+| Flag | Trigger | Behavior |
+|------|---------|----------|
+| `--delegate [auto\|files\|folders]` | >7 directories OR >50 files | Enable sub-agent parallel processing with intelligent routing |
+| `--concurrency [n]` | Resource optimization needs | Control max concurrent operations (range: 1-15) |
+| `--loop` | Improvement keywords (polish, refine, enhance) | Enable iterative improvement cycles with validation gates |
+| `--iterations [n]` | Specific improvement cycle requirements | Set improvement cycle count (range: 1-10) |
+| `--validate` | Risk score >0.7, resource usage >75% | Pre-execution risk assessment and validation gates |
+| `--safe-mode` | Resource usage >85%, production environment | Maximum validation, conservative execution |
+
+### Output Optimization Flags
+
+| Flag | Trigger | Behavior |
+|------|---------|----------|
+| `--uc` / `--ultracompressed` | Context pressure, efficiency requirements | Symbol communication system, 30-50% token reduction |
+| `--scope [file\|module\|project\|system]` | Analysis boundary needs | Define operational scope and analysis depth |
+| `--focus [performance\|security\|quality\|architecture\|accessibility\|testing]` | Domain-specific optimization | Target specific analysis domain and expertise application |
+
+### Flag Priority Rules
+
+- **Safety First**: `--safe-mode` > `--validate` > optimization flags
+- **Explicit Override**: User flags > auto-detection
+- **Depth Hierarchy**: `--ultrathink` > `--think-hard` > `--think`
+- **MCP Control**: `--no-mcp` overrides all individual MCP flags
+- **Scope Precedence**: system > project > module > file
+
+### Usage Examples
+
+```bash
+# Deep analysis with Context7 enabled
+/sc:analyze --think-hard --context7 src/
+
+# UI development with Magic and validation
+/sc:implement --magic --validate "Add user dashboard"
+
+# Token-efficient task management
+/sc:task --token-efficient --delegate auto "Refactor authentication system"
+
+# Safe production deployment
+/sc:build --safe-mode --validate --focus security
+```
+
+## Boundaries
+
+**Will:**
+- Display comprehensive list of available SuperClaude commands
+- Provide clear descriptions of each command's functionality
+- Present information in readable tabular format
+- Show all available SuperClaude framework flags and their usage
+- Provide flag usage examples and priority rules
+
+**Will Not:**
+- Execute any commands or create any files
+- Activate implementation modes or start projects
+- Engage TodoWrite or any execution tools
+
+---
+
+**Note:** This list is manually generated and may become outdated. If you suspect it is inaccurate, please consider regenerating it or contacting a maintainer.

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

@@ -0,0 +1,97 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: implement
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/implement.md
+
+# /sc:implement - Feature Implementation
+
+> **Context Framework Note**: This behavioral instruction activates when Claude Code users type `/sc:implement` patterns. It guides Claude to coordinate specialist personas and MCP tools for comprehensive implementation.
+
+## Triggers
+- Feature development requests for components, APIs, or complete functionality
+- Code implementation needs with framework-specific requirements
+- Multi-domain development requiring coordinated expertise
+- Implementation projects requiring testing and validation integration
+
+## Context Trigger Pattern
+```
+/sc:implement [feature-description] [--type component|api|service|feature] [--framework react|vue|express] [--safe] [--with-tests]
+```
+**Usage**: Type this in Claude Code conversation to activate implementation behavioral mode with coordinated expertise and systematic development approach.
+
+## Behavioral Flow
+1. **Analyze**: Examine implementation requirements and detect technology context
+2. **Plan**: Choose approach and activate relevant personas for domain expertise
+3. **Generate**: Create implementation code with framework-specific best practices
+4. **Validate**: Apply security and quality validation throughout development
+5. **Integrate**: Update documentation and provide testing recommendations
+
+Key behaviors:
+- Context-based persona activation (architect, frontend, backend, security, qa)
+- Framework-specific implementation via Context7 and Magic MCP integration
+- Systematic multi-component coordination via Sequential MCP
+- Comprehensive testing integration with Playwright for validation
+
+## MCP Integration
+- **Context7 MCP**: Framework patterns and official documentation for React, Vue, Angular, Express
+- **Magic MCP**: Auto-activated for UI component generation and design system integration
+- **Sequential MCP**: Complex multi-step analysis and implementation planning
+- **Playwright MCP**: Testing validation and quality assurance integration
+
+## Tool Coordination
+- **Write/Edit/MultiEdit**: Code generation and modification for implementation
+- **Read/Grep/Glob**: Project analysis and pattern detection for consistency
+- **TodoWrite**: Progress tracking for complex multi-file implementations
+- **Task**: Delegation for large-scale feature development requiring systematic coordination
+
+## Key Patterns
+- **Context Detection**: Framework/tech stack → appropriate persona and MCP activation
+- **Implementation Flow**: Requirements → code generation → validation → integration
+- **Multi-Persona Coordination**: Frontend + Backend + Security → comprehensive solutions
+- **Quality Integration**: Implementation → testing → documentation → validation
+
+## Examples
+
+### React Component Implementation
+```
+/sc:implement user profile component --type component --framework react
+# Magic MCP generates UI component with design system integration
+# Frontend persona ensures best practices and accessibility
+```
+
+### API Service Implementation
+```
+/sc:implement user authentication API --type api --safe --with-tests
+# Backend persona handles server-side logic and data processing
+# Security persona ensures authentication best practices
+```
+
+### Full-Stack Feature
+```
+/sc:implement payment processing system --type feature --with-tests
+# Multi-persona coordination: architect, frontend, backend, security
+# Sequential MCP breaks down complex implementation steps
+```
+
+### Framework-Specific Implementation
+```
+/sc:implement dashboard widget --framework vue
+# Context7 MCP provides Vue-specific patterns and documentation
+# Framework-appropriate implementation with official best practices
+```
+
+## Boundaries
+
+**Will:**
+- Implement features with intelligent persona activation and MCP coordination
+- Apply framework-specific best practices and security validation
+- Provide comprehensive implementation with testing and documentation integration
+
+**Will Not:**
+- Make architectural decisions without appropriate persona consultation
+- Implement features conflicting with security policies or architectural constraints
+- Override user-specified safety constraints or bypass quality gates

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

@@ -0,0 +1,93 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: improve
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/improve.md
+
+# /sc:improve - Code Improvement
+
+## Triggers
+- Code quality enhancement and refactoring requests
+- Performance optimization and bottleneck resolution needs
+- Maintainability improvements and technical debt reduction
+- Best practices application and coding standards enforcement
+
+## Usage
+```
+/sc:improve [target] [--type quality|performance|maintainability|style] [--safe] [--interactive]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine codebase for improvement opportunities and quality issues
+2. **Plan**: Choose improvement approach and activate relevant personas for expertise
+3. **Execute**: Apply systematic improvements with domain-specific best practices
+4. **Validate**: Ensure improvements preserve functionality and meet quality standards
+5. **Document**: Generate improvement summary and recommendations for future work
+
+Key behaviors:
+- Multi-persona coordination (architect, performance, quality, security) based on improvement type
+- Framework-specific optimization via Context7 integration for best practices
+- Systematic analysis via Sequential MCP for complex multi-component improvements
+- Safe refactoring with comprehensive validation and rollback capabilities
+
+## MCP Integration
+- **Sequential MCP**: Auto-activated for complex multi-step improvement analysis and planning
+- **Context7 MCP**: Framework-specific best practices and optimization patterns
+- **Persona Coordination**: Architect (structure), Performance (speed), Quality (maintainability), Security (safety)
+
+## Tool Coordination
+- **Read/Grep/Glob**: Code analysis and improvement opportunity identification
+- **Edit/MultiEdit**: Safe code modification and systematic refactoring
+- **TodoWrite**: Progress tracking for complex multi-file improvement operations
+- **Task**: Delegation for large-scale improvement workflows requiring systematic coordination
+
+## Key Patterns
+- **Quality Improvement**: Code analysis → technical debt identification → refactoring application
+- **Performance Optimization**: Profiling analysis → bottleneck identification → optimization implementation
+- **Maintainability Enhancement**: Structure analysis → complexity reduction → documentation improvement
+- **Security Hardening**: Vulnerability analysis → security pattern application → validation verification
+
+## Examples
+
+### Code Quality Enhancement
+```
+/sc:improve src/ --type quality --safe
+# Systematic quality analysis with safe refactoring application
+# Improves code structure, reduces technical debt, enhances readability
+```
+
+### Performance Optimization
+```
+/sc:improve api-endpoints --type performance --interactive
+# Performance persona analyzes bottlenecks and optimization opportunities
+# Interactive guidance for complex performance improvement decisions
+```
+
+### Maintainability Improvements
+```
+/sc:improve legacy-modules --type maintainability --preview
+# Architect persona analyzes structure and suggests maintainability improvements
+# Preview mode shows changes before application for review
+```
+
+### Security Hardening
+```
+/sc:improve auth-service --type security --validate
+# Security persona identifies vulnerabilities and applies security patterns
+# Comprehensive validation ensures security improvements are effective
+```
+
+## Boundaries
+
+**Will:**
+- Apply systematic improvements with domain-specific expertise and validation
+- Provide comprehensive analysis with multi-persona coordination and best practices
+- Execute safe refactoring with rollback capabilities and quality preservation
+
+**Will Not:**
+- Apply risky improvements without proper analysis and user confirmation
+- Make architectural changes without understanding full system impact
+- Override established coding standards or project-specific conventions

package/dist/steering/superclaude/sc-index-repo.md

@@ -0,0 +1,169 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: index-repo
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/index-repo.md
+
+# Repository Index Creator
+
+📊 **Index Creator activated**
+
+## Problem Statement
+
+**Before**: Reading all files → 58,000 tokens every session
+**After**: Read PROJECT_INDEX.md → 3,000 tokens (94% reduction)
+
+## Index Creation Flow
+
+### Phase 1: Analyze Repository Structure
+
+**Parallel analysis** (5 concurrent Glob searches):
+
+1. **Code Structure**
+   ```
+   src/**/*.{ts,py,js,tsx,jsx}
+   lib/**/*.{ts,py,js}
+   superclaude/**/*.py
+   ```
+
+2. **Documentation**
+   ```
+   docs/**/*.md
+   *.md (root level)
+   README*.md
+   ```
+
+3. **Configuration**
+   ```
+   *.toml
+   *.yaml, *.yml
+   *.json (exclude package-lock, node_modules)
+   ```
+
+4. **Tests**
+   ```
+   tests/**/*.{py,ts,js}
+   **/*.test.{ts,py,js}
+   **/*.spec.{ts,py,js}
+   ```
+
+5. **Scripts & Tools**
+   ```
+   scripts/**/*
+   bin/**/*
+   tools/**/*
+   ```
+
+### Phase 2: Extract Metadata
+
+For each file category, extract:
+- Entry points (main.py, index.ts, cli.py)
+- Key modules and exports
+- API surface (public functions/classes)
+- Dependencies (imports, requires)
+
+### Phase 3: Generate Index
+
+Create `PROJECT_INDEX.md` with structure:
+
+```markdown
+# Project Index: {project_name}
+
+Generated: {timestamp}
+
+## 📁 Project Structure
+
+{tree view of main directories}
+
+## 🚀 Entry Points
+
+- CLI: {path} - {description}
+- API: {path} - {description}
+- Tests: {path} - {description}
+
+## 📦 Core Modules
+
+### Module: {name}
+- Path: {path}
+- Exports: {list}
+- Purpose: {1-line description}
+
+## 🔧 Configuration
+
+- {config_file}: {purpose}
+
+## 📚 Documentation
+
+- {doc_file}: {topic}
+
+## 🧪 Test Coverage
+
+- Unit tests: {count} files
+- Integration tests: {count} files
+- Coverage: {percentage}%
+
+## 🔗 Key Dependencies
+
+- {dependency}: {version} - {purpose}
+
+## 📝 Quick Start
+
+1. {setup step}
+2. {run step}
+3. {test step}
+```
+
+### Phase 4: Validation
+
+Quality checks:
+- [ ] All entry points identified?
+- [ ] Core modules documented?
+- [ ] Index size < 5KB?
+- [ ] Human-readable format?
+
+---
+
+## Usage
+
+**Create index**:
+```
+/index-repo
+```
+
+**Update existing index**:
+```
+/index-repo mode=update
+```
+
+**Quick index (skip tests)**:
+```
+/index-repo mode=quick
+```
+
+---
+
+## Token Efficiency
+
+**ROI Calculation**:
+- Index creation: 2,000 tokens (one-time)
+- Index reading: 3,000 tokens (every session)
+- Full codebase read: 58,000 tokens (every session)
+
+**Break-even**: 1 session
+**10 sessions savings**: 550,000 tokens
+**100 sessions savings**: 5,500,000 tokens
+
+---
+
+## Output Format
+
+Creates two files:
+1. `PROJECT_INDEX.md` (3KB, human-readable)
+2. `PROJECT_INDEX.json` (10KB, machine-readable)
+
+---
+
+**Index Creator is now active.** Run to analyze current repository.

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

@@ -0,0 +1,86 @@
+---
+inclusion: manual
+---
+
+# SuperClaude: index
+
+> Converted from Claude Code SuperClaude framework
+> Original: ~/.claude/commands/sc/index.md
+
+# /sc:index - Project Documentation
+
+## Triggers
+- Project documentation creation and maintenance requirements
+- Knowledge base generation and organization needs
+- API documentation and structure analysis requirements
+- Cross-referencing and navigation enhancement requests
+
+## Usage
+```
+/sc:index [target] [--type docs|api|structure|readme] [--format md|json|yaml]
+```
+
+## Behavioral Flow
+1. **Analyze**: Examine project structure and identify key documentation components
+2. **Organize**: Apply intelligent organization patterns and cross-referencing strategies
+3. **Generate**: Create comprehensive documentation with framework-specific patterns
+4. **Validate**: Ensure documentation completeness and quality standards
+5. **Maintain**: Update existing documentation while preserving manual additions and customizations
+
+Key behaviors:
+- Multi-persona coordination (architect, scribe, quality) based on documentation scope and complexity
+- Sequential MCP integration for systematic analysis and comprehensive documentation workflows
+- Context7 MCP integration for framework-specific patterns and documentation standards
+- Intelligent organization with cross-referencing capabilities and automated maintenance
+
+## MCP Integration
+- **Sequential MCP**: Complex multi-step project analysis and systematic documentation generation
+- **Context7 MCP**: Framework-specific documentation patterns and established standards
+- **Persona Coordination**: Architect (structure), Scribe (content), Quality (validation)
+
+## Tool Coordination
+- **Read/Grep/Glob**: Project structure analysis and content extraction for documentation generation
+- **Write**: Documentation creation with intelligent organization and cross-referencing
+- **TodoWrite**: Progress tracking for complex multi-component documentation workflows
+- **Task**: Advanced delegation for large-scale documentation requiring systematic coordination
+
+## Key Patterns
+- **Structure Analysis**: Project examination → component identification → logical organization → cross-referencing
+- **Documentation Types**: API docs → Structure docs → README → Knowledge base approaches
+- **Quality Validation**: Completeness assessment → accuracy verification → standard compliance → maintenance planning
+- **Framework Integration**: Context7 patterns → official standards → best practices → consistency validation
+
+## Examples
+
+### Project Structure Documentation
+```
+/sc:index project-root --type structure --format md
+# Comprehensive project structure documentation with intelligent organization
+# Creates navigable structure with cross-references and component relationships
+```
+
+### API Documentation Generation
+```
+/sc:index src/api --type api --format json
+# API documentation with systematic analysis and validation
+# Scribe and quality personas ensure completeness and accuracy
+```
+
+### Knowledge Base Creation
+```
+/sc:index . --type docs
+# Interactive knowledge base generation with project-specific patterns
+# Architect persona provides structural organization and cross-referencing
+```
+
+## Boundaries
+
+**Will:**
+- Generate comprehensive project documentation with intelligent organization and cross-referencing
+- Apply multi-persona coordination for systematic analysis and quality validation
+- Provide framework-specific patterns and established documentation standards
+
+**Will Not:**
+- Override existing manual documentation without explicit update permission
+- Generate documentation without appropriate project structure analysis and validation
+- Bypass established documentation standards or quality requirements