kiro-kit 0.1.0

package/dist/presets/backend/skills/code-review/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: code-review
+description: Structured code review practices for receiving feedback, requesting reviews, and verification gates. Use when reviewing or receiving review feedback on code changes.
+---
+
+# Code Review
+
+Activate this skill when performing or receiving code reviews.
+
+## When to Use
+
+- Receiving code review feedback
+- Completing tasks requiring review before proceeding
+- Before making completion claims about implementations
+- Requesting reviews via subagent workflows
+
+## Receiving Feedback
+
+- Apply technical rigor over performative agreement
+- If feedback is unclear, ask for clarification with specific questions
+- If feedback is technically questionable, explain your reasoning
+- Never change code just to appease a reviewer without understanding why
+
+## Requesting Reviews
+
+- Provide context: what changed, why, and what to focus on
+- Highlight areas of uncertainty or risk
+- Include test results and verification evidence
+- Note any trade-offs or decisions made
+
+## Verification Gates
+
+Before claiming work is complete:
+- Run the test suite and confirm passing
+- Verify the build succeeds
+- Check for type errors and lint warnings
+- Confirm the change addresses the original requirement
+- Provide evidence of verification (command output, test results)
+
+## Rules
+
+- Never claim completion without evidence
+- Honest feedback is more valuable than agreement
+- Focus on correctness, security, and maintainability
+- Style preferences are lower priority than functional issues

package/dist/presets/backend/skills/databases/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: databases
+description: Work with PostgreSQL, MongoDB, and Redis for schema design, query optimization, migrations, and data modeling. Use when designing or optimizing data layers.
+---
+
+# Databases
+
+Activate this skill when working with database design, queries, migrations, or optimization.
+
+## When to Use
+
+- Designing database schemas and relationships
+- Writing complex queries or aggregation pipelines
+- Optimizing slow queries with indexes and execution plans
+- Planning and executing database migrations
+- Configuring replication, backups, or sharding
+- Choosing between SQL and NoSQL for a use case
+
+## PostgreSQL
+
+- Use EXPLAIN ANALYZE for query optimization
+- Create indexes based on WHERE, JOIN, and ORDER BY patterns
+- Use partial indexes for filtered queries
+- Prefer UUID or ULID for distributed primary keys
+- Use transactions for multi-statement operations
+- Implement row-level security for multi-tenant apps
+
+## MongoDB
+
+- Design schemas around access patterns (embed vs reference)
+- Use compound indexes matching query patterns
+- Leverage aggregation pipeline for complex transformations
+- Use change streams for real-time data sync
+- Implement schema validation at the database level
+
+## Redis
+
+- Use appropriate data structures (strings, hashes, sorted sets, streams)
+- Set TTL on all cache entries
+- Use Redis transactions (MULTI/EXEC) for atomic operations
+- Implement pub/sub for real-time messaging
+- Use Redis Streams for reliable message queues
+
+## Migration Rules
+
+- Migrations must be reversible (up and down)
+- Never modify a deployed migration -- create a new one
+- Test migrations against production-like data volumes
+- Use zero-downtime migration patterns for live systems
+- Back up data before destructive migrations

package/dist/presets/backend/skills/debugging/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: debugging
+description: Systematic debugging framework for investigating root causes before applying fixes. Use when encountering bugs, test failures, or unexpected behavior.
+---
+
+# Debugging
+
+Activate this skill when encountering bugs, test failures, or unexpected behavior.
+
+## When to Use
+
+- Tests are failing unexpectedly
+- Runtime errors or crashes occur
+- Behavior does not match expectations
+- Performance degrades without obvious cause
+- Build or compilation errors appear
+
+## Process
+
+1. Reproduce the issue consistently
+2. Gather evidence (error messages, stack traces, logs)
+3. Form hypothesis about root cause
+4. Trace backward from the symptom to the source
+5. Validate hypothesis with targeted tests
+6. Apply minimal fix addressing root cause
+7. Verify fix resolves the issue without regressions
+
+## Rules
+
+- Never apply random fixes without understanding the cause
+- Measure and trace before changing code
+- If a fix attempt fails twice, step back and reconsider the hypothesis
+- Check recent changes (git log) as first investigation step
+- Isolate the problem to the smallest reproducible case

package/dist/presets/backend/skills/devops/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: devops
+description: Deploy and manage infrastructure with Docker, Kubernetes, CI/CD pipelines, and cloud services. Use when containerizing, deploying, or managing production infrastructure.
+---
+
+# DevOps
+
+Activate this skill when working with containers, deployments, CI/CD, or cloud infrastructure.
+
+## When to Use
+
+- Writing or optimizing Dockerfiles
+- Configuring docker-compose for local development
+- Setting up CI/CD pipelines (GitHub Actions, GitLab CI)
+- Managing cloud infrastructure (AWS, GCP, Cloudflare)
+- Implementing deployment strategies
+- Configuring monitoring and alerting
+- Writing infrastructure-as-code (Terraform, Pulumi)
+
+## Docker Best Practices
+
+- Use multi-stage builds to minimize image size
+- Run as non-root user in production
+- Pin base image versions (not :latest)
+- Use .dockerignore to exclude unnecessary files
+- Add HEALTHCHECK instructions
+- Set resource limits (memory, CPU)
+- Order layers for optimal caching (dependencies before source)
+
+## CI/CD Pipeline Stages
+
+1. Lint and typecheck
+2. Unit tests
+3. Build artifacts
+4. Integration tests
+5. Security scan (dependencies + container)
+6. Deploy to staging
+7. Smoke tests
+8. Deploy to production (with approval gate)
+
+## Deployment Strategies
+
+- Blue-green: instant rollback, double resources
+- Canary: gradual rollout, early detection
+- Rolling: zero-downtime, incremental replacement
+- Feature flags: decouple deploy from release
+
+## Monitoring
+
+- Application metrics: request rate, error rate, latency (RED)
+- Infrastructure metrics: CPU, memory, disk, network
+- Business metrics: signups, conversions, revenue
+- Alerting: page on symptoms, not causes

package/dist/presets/backend/skills/docs-seeker/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: docs-seeker
+description: Search and retrieve technical documentation from official sources. Use when you need current documentation for libraries, frameworks, or APIs.
+---
+
+# Docs Seeker
+
+Activate this skill when you need to find or verify technical documentation.
+
+## When to Use
+
+- Looking up API documentation for a library
+- Finding configuration options for a framework
+- Verifying correct usage of a function or method
+- Checking version-specific behavior or breaking changes
+- Finding migration guides between versions
+
+## Process
+
+1. Identify the library/framework and version
+2. Search official documentation sources first
+3. Check for llms.txt or context7.com sources
+4. Verify information against the specific version in use
+5. Extract relevant code examples and configuration
+
+## Sources Priority
+
+1. Official documentation (docs site, README)
+2. llms.txt / context7.com aggregated docs
+3. GitHub repository (source code, issues, discussions)
+4. Release notes and changelogs
+5. Community resources (verified accuracy)
+
+## Rules
+
+- Always verify documentation matches the version in use
+- Prefer code examples from official sources
+- Note when documentation is incomplete or outdated
+- Cross-reference multiple sources for critical information
+- Include links to source documentation

package/dist/presets/backend/skills/frontend-design/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: frontend-design
+description: Create production-grade frontend interfaces when backend services need admin panels, dashboards, or API documentation UIs. Use when building web interfaces for backend services.
+---
+
+# Frontend Design
+
+Activate this skill when building admin panels, dashboards, or documentation UIs for backend services.
+
+## When to Use
+
+- Building admin dashboards for backend services
+- Creating API documentation interfaces
+- Designing monitoring and observability UIs
+- Building internal tools and management panels
+
+## Design Principles
+
+- Function over form for internal tools
+- Clear data presentation with tables and charts
+- Responsive but desktop-first for admin interfaces
+- Consistent spacing using 4px/8px grid system
+- Accessible color contrast (WCAG 2.1 AA minimum)
+
+## Implementation Guidelines
+
+- Use semantic HTML elements for structure
+- Keep styling minimal and functional
+- Implement proper loading and error states
+- Use server-rendered pages where possible
+- Prioritize data density over visual flair for admin tools
+
+## Rules
+
+- Admin UIs should prioritize usability over aesthetics
+- Always include loading states for async data
+- Implement proper error handling with retry options
+- Use pagination for large data sets
+- Include search and filter capabilities for lists

package/dist/presets/backend/skills/mcp-builder/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: mcp-builder
+description: Guide for creating MCP (Model Context Protocol) servers that enable LLMs to interact with external services. Use when building MCP server integrations.
+---
+
+# MCP Builder
+
+Activate this skill when building MCP servers to integrate external APIs or services.
+
+## When to Use
+
+- Creating a new MCP server for an API
+- Adding tools, prompts, or resources to an MCP server
+- Debugging MCP server connectivity
+- Designing tool schemas for LLM consumption
+
+## MCP Server Structure
+
+- Tools: functions the LLM can call
+- Resources: data the LLM can read
+- Prompts: pre-built prompt templates
+
+## Implementation (TypeScript)
+
+```typescript
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+
+const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+
+server.tool('tool-name', { param: z.string() }, async ({ param }) => {
+  return { content: [{ type: 'text', text: result }] };
+});
+```
+
+## Implementation (Python)
+
+```python
+from mcp.server.fastmcp import FastMCP
+
+mcp = FastMCP("my-server")
+
+@mcp.tool()
+def tool_name(param: str) -> str:
+    return result
+```
+
+## Rules
+
+- Design tools with clear, specific names
+- Use Zod/Pydantic schemas for input validation
+- Handle errors gracefully with informative messages
+- Keep tool descriptions concise but complete
+- Test tools independently before integration

package/dist/presets/backend/skills/mcp-management/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: mcp-management
+description: Manage MCP servers -- discover, analyze, and execute tools from configured servers. Use when working with MCP integrations or discovering available capabilities.
+---
+
+# MCP Management
+
+Activate this skill when managing MCP server configurations or discovering capabilities.
+
+## When to Use
+
+- Discovering available MCP tools across servers
+- Configuring new MCP server connections
+- Troubleshooting MCP connectivity issues
+- Filtering tools for specific tasks
+- Managing multi-server environments
+
+## Configuration
+
+MCP servers are configured in `.kiro/settings/mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "server-name": {
+      "command": "npx",
+      "args": ["-y", "@package/mcp-server"],
+      "env": { "API_KEY": "${ENV_VAR}" }
+    }
+  }
+}
+```
+
+## Rules
+
+- Verify server availability before execution
+- Never expose credentials in tool output
+- Use environment variables for sensitive values
+- Test tool parameters against schema before calling
+- Handle timeouts and connection failures gracefully

package/dist/presets/backend/skills/media-processing/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: media-processing
+description: Process multimedia files with FFmpeg and ImageMagick for encoding, conversion, and manipulation. Use when working with video, audio, or image processing pipelines.
+---
+
+# Media Processing
+
+Activate this skill when processing media files (video, audio, images).
+
+## When to Use
+
+- Converting media formats
+- Encoding video with specific codecs
+- Extracting audio from video
+- Resizing or cropping images
+- Generating thumbnails
+- Creating streaming manifests (HLS/DASH)
+- Batch processing media files
+
+## FFmpeg Common Operations
+
+```bash
+# Convert format
+ffmpeg -i input.mp4 -c:v libx264 -crf 23 output.mp4
+
+# Extract audio
+ffmpeg -i video.mp4 -vn -acodec libmp3lame audio.mp3
+
+# Generate thumbnail
+ffmpeg -i video.mp4 -ss 00:00:05 -frames:v 1 thumb.jpg
+
+# HLS streaming
+ffmpeg -i input.mp4 -codec: copy -start_number 0 -hls_time 10 -f hls output.m3u8
+```
+
+## ImageMagick Common Operations
+
+```bash
+# Resize
+convert input.jpg -resize 800x600 output.jpg
+
+# Format conversion
+convert input.png output.webp
+
+# Batch processing
+mogrify -resize 50% -format webp *.png
+```
+
+## Rules
+
+- Always specify output codec explicitly
+- Use hardware acceleration when available
+- Set quality parameters appropriate for use case
+- Validate output files after processing
+- Handle large files with streaming (avoid loading into memory)

package/dist/presets/backend/skills/planning/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: planning
+description: Plan technical solutions that are scalable, secure, and maintainable. Use when you need to decompose features, evaluate approaches, or create implementation plans.
+---
+
+# Planning
+
+Activate this skill when planning features, evaluating approaches, or creating implementation strategies.
+
+## When to Use
+
+- Starting a new feature or project
+- Evaluating multiple technical approaches
+- Decomposing complex requirements into tasks
+- Assessing risks and dependencies
+- Creating time-boxed implementation plans
+
+## Process
+
+1. Define success criteria and constraints
+2. Research relevant patterns and prior art
+3. Decompose into phases (3-7 typical)
+4. Identify dependencies and critical path
+5. Assess risks and define mitigations
+6. Create actionable task list with time estimates
+7. Document unresolved questions
+
+## Output Format
+
+Plans go in `plans/YYYYMMDD-HHmm-plan-name/`:
+- `plan.md`: overview, phase list, status tracking
+- `phase-XX-name.md`: detailed phase specifications
+
+## Rules
+
+- Every task should be completable in 30 min to 2 hours
+- Plans must be actionable, not aspirational
+- Include rollback strategy for risky phases
+- Apply YAGNI: plan only what is needed now

package/dist/presets/backend/skills/problem-solving/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: problem-solving
+description: Apply systematic problem-solving techniques for complexity spirals, innovation blocks, recurring patterns, and scale uncertainty. Use when stuck or facing novel challenges.
+---
+
+# Problem Solving
+
+Activate this skill when facing complex problems, getting stuck, or needing structured approaches to novel challenges.
+
+## When to Use
+
+- Complexity is spiraling out of control
+- Stuck on a problem after multiple attempts
+- Recurring patterns suggest a deeper issue
+- Assumptions are constraining the solution space
+- Scale or scope is uncertain
+
+## Techniques
+
+### Simplification Cascade
+When complexity spirals: remove features until the core works, then add back one at a time.
+
+### Inversion Exercise
+When assumptions constrain: ask "what if the opposite were true?" to find hidden solutions.
+
+### Meta-Pattern Recognition
+When patterns recur: identify the underlying cause rather than fixing symptoms repeatedly.
+
+### Scale Game
+When scale is uncertain: design for 10x current load, validate at 1x, plan for 100x.
+
+### Collision-Zone Thinking
+When innovation is blocked: combine two unrelated concepts to find novel approaches.
+
+## Rules
+
+- If stuck after 3 attempts, change the approach entirely
+- Question every assumption explicitly
+- Prefer reversible decisions over perfect ones
+- Solve the simplest version of the problem first
+- Document what was tried and why it failed

package/dist/presets/backend/skills/repomix/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: repomix
+description: Package code repositories into single AI-friendly files for analysis. Use when you need to understand unfamiliar codebases or prepare context for AI consumption.
+---
+
+# Repomix
+
+Activate this skill when packaging codebases for analysis or understanding repository structure.
+
+## When to Use
+
+- Analyzing an unfamiliar codebase
+- Creating repository snapshots for context
+- Preparing code for security audits
+- Generating documentation context
+- Evaluating third-party libraries
+
+## Usage
+
+```bash
+# Pack current directory
+repomix
+
+# Pack with specific includes
+repomix --include "src/**/*.ts"
+
+# Pack remote repository
+repomix --remote https://github.com/user/repo
+
+# Output formats
+repomix --style xml    # default, best for AI
+repomix --style markdown
+repomix --style plain
+```
+
+## Rules
+
+- Use include/exclude patterns to focus on relevant code
+- Prefer XML format for AI consumption (best token efficiency)
+- Exclude test fixtures, build output, and node_modules
+- Use --remote for analyzing external repositories
+- Check output size before feeding to AI (token limits)

package/dist/presets/backend/skills/research/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: research
+description: Research and evaluate technical solutions, libraries, and patterns. Use when you need to investigate options before making architectural or technology decisions.
+---
+
+# Research
+
+Activate this skill when evaluating technologies, comparing libraries, or investigating best practices.
+
+## When to Use
+
+- Evaluating competing libraries or frameworks
+- Investigating best practices for a specific domain
+- Comparing architectural approaches
+- Assessing security implications of a technology choice
+- Understanding unfamiliar APIs or protocols
+
+## Process
+
+1. Define the research question precisely
+2. Identify authoritative sources (official docs, RFCs, benchmarks)
+3. Gather data from multiple sources
+4. Cross-reference and validate findings
+5. Evaluate trade-offs in context of the project
+6. Produce actionable recommendation with confidence level
+
+## Rules
+
+- Prioritize official documentation over blog posts
+- Note version numbers and compatibility requirements
+- Distinguish proven patterns from experimental approaches
+- State confidence level for each recommendation
+- Flag when information may be outdated
+- Include maintenance status and community health of libraries

package/dist/presets/backend/skills/sequential-thinking/SKILL.md

@@ -0,0 +1,33 @@
+---
+name: sequential-thinking
+description: Apply structured, reflective problem-solving for complex tasks requiring multi-step analysis and revision. Use for complex decomposition or when you need to think step by step.
+---
+
+# Sequential Thinking
+
+Activate this skill for complex problems requiring structured, step-by-step reasoning.
+
+## When to Use
+
+- Complex problem decomposition
+- Multi-step analysis requiring course correction
+- Problems with unclear scope or requirements
+- Hypothesis-driven investigation
+- Architecture decisions with many trade-offs
+
+## Process
+
+1. State the problem clearly in one sentence
+2. Identify what you know and what you need to find out
+3. Break into sequential steps, each building on the previous
+4. At each step, validate assumptions before proceeding
+5. If a step reveals new information, revise earlier conclusions
+6. Summarize findings and recommended action
+
+## Rules
+
+- Each step must be independently verifiable
+- Revise earlier steps when new evidence contradicts them
+- State confidence level at each step
+- Identify decision points and their trade-offs
+- Keep the chain of reasoning visible and traceable

package/dist/presets/backend/skills/skill-creator/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: skill-creator
+description: Guide for creating effective skills that extend agent capabilities with specialized knowledge and workflows. Use when building new skills.
+---
+
+# Skill Creator
+
+Activate this skill when creating or updating agent skills.
+
+## When to Use
+
+- Creating a new skill for specialized knowledge
+- Updating an existing skill with new capabilities
+- Organizing skill content for progressive disclosure
+- Adding reference files or scripts to a skill
+
+## Skill Structure
+
+```
+skills/skill-name/
+  SKILL.md           Main skill file (concise, token-efficient)
+  references/        Detailed documentation (loaded on demand)
+  scripts/           Executable scripts for the skill
+  assets/            Static assets (templates, configs)
+  tests/             Skill-specific tests
+```
+
+## SKILL.md Format
+
+```markdown
+---
+name: skill-name
+description: When to activate this skill (one sentence)
+---
+
+# Skill Name
+
+Brief overview (2-3 sentences).
+
+## When to Use
+[Bullet list of activation triggers]
+
+## Process
+[Numbered steps for using the skill]
+
+## Rules
+[Key constraints and guidelines]
+```
+
+## Rules
+
+- Keep SKILL.md under 100 lines for token efficiency
+- Put detailed content in references/ directory
+- Use progressive disclosure: summary in SKILL.md, details in references
+- Include clear activation triggers in description
+- Test skills with representative scenarios

package/dist/presets/backend/skills/template-skill/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: template-skill
+description: Template for creating new skills. Copy this directory and customize for your specific use case.
+---
+
+# Template Skill
+
+This is a template for creating new skills. Copy this directory and customize.
+
+## When to Use
+
+- [Describe when this skill should be activated]
+- [List specific triggers or scenarios]
+
+## Process
+
+1. [First step]
+2. [Second step]
+3. [Third step]
+
+## Rules
+
+- [Key constraint or guideline]
+- [Another important rule]
+- [Quality standard to maintain]