kiro-kit 0.1.0

package/dist/presets/devops/skills/ci-cd-patterns/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: ci-cd-patterns
+description: Design and implement CI/CD pipeline patterns for reliable, fast, and secure software delivery. Use when building or optimizing build and deployment pipelines.
+---
+
+# CI/CD Patterns
+
+Activate this skill when designing or optimizing CI/CD pipelines.
+
+## When to Use
+
+- Designing new CI/CD pipelines
+- Optimizing build times and caching
+- Implementing deployment strategies
+- Adding security scanning to pipelines
+- Setting up multi-environment promotion
+- Configuring GitOps workflows
+
+## Pipeline Stages
+
+1. Validate: lint, format check, schema validation
+2. Build: compile, bundle, create artifacts
+3. Test: unit, integration, contract tests
+4. Scan: SAST, dependency audit, container scan
+5. Package: build container image, push to registry
+6. Deploy: apply to target environment
+7. Verify: smoke tests, health checks, canary analysis
+
+## Deployment Strategies
+
+- Rolling: gradual replacement, zero-downtime
+- Blue-Green: instant switch between environments
+- Canary: route percentage of traffic to new version
+- Feature Flags: deploy dark, enable incrementally
+
+## Rules
+
+- Fail fast: cheapest checks run first
+- Cache aggressively: dependencies, layers, build artifacts
+- Pin versions: actions, base images, dependencies
+- Use OIDC: no long-lived credentials in CI
+- Separate build from deploy for auditability
+- Every deployment must be reversible
+- Quality gates must block on failure
+- Pipeline changes require code review

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

@@ -0,0 +1,30 @@
+---
+name: code-review
+description: Systematic 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 implementation
+- Reviewing pull requests for quality and correctness
+
+## Practices
+
+1. Receiving feedback: apply technical rigor over performative agreement
+2. Requesting reviews: provide clear context and scope
+3. Verification gates: require evidence before status claims
+
+## Rules
+
+- Never claim completion without running tests
+- Address all critical and high-priority feedback
+- Provide evidence (test output, build logs) with completion claims
+- Focus on correctness, security, and maintainability
+- Be constructive and specific in feedback
+- Separate style preferences from correctness issues

package/dist/presets/devops/skills/container-security/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: container-security
+description: Secure container images and runtime environments. Use when building Dockerfiles, scanning images, or hardening container deployments.
+---
+
+# Container Security
+
+Activate this skill when securing container images and runtime environments.
+
+## When to Use
+
+- Building secure Dockerfiles
+- Scanning images for vulnerabilities
+- Configuring container runtime security
+- Implementing image signing and verification
+- Setting up admission controllers
+- Hardening Kubernetes pod security
+
+## Best Practices
+
+- Use minimal base images (distroless, alpine, scratch)
+- Run containers as non-root user
+- Drop all capabilities, add only what is needed
+- Use read-only root filesystem where possible
+- Scan images in CI pipeline before pushing to registry
+- Sign images with cosign or Notary
+- Set resource limits to prevent DoS
+- Use seccomp and AppArmor profiles
+
+## Scanning Tools
+
+- Trivy: comprehensive vulnerability scanner
+- Grype: container image vulnerability scanner
+- Hadolint: Dockerfile linter
+- Dockle: container image security linter
+
+## Rules
+
+- Never use `latest` tag in production
+- Never run as root unless absolutely required
+- Never store secrets in image layers
+- Always scan before deploying to production
+- Pin all package versions in Dockerfiles
+- Remove build tools from final image stage

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

@@ -0,0 +1,34 @@
+---
+name: databases
+description: Work with databases (PostgreSQL, MySQL, MongoDB) for schema design, query optimization, migrations, and administration. Use when dealing with data layer concerns.
+---
+
+# Databases
+
+Activate this skill when working with database systems.
+
+## When to Use
+
+- Designing database schemas
+- Writing or optimizing queries
+- Planning migrations
+- Configuring replication or backups
+- Troubleshooting performance issues
+- Managing database users and permissions
+
+## Supported Systems
+
+- PostgreSQL: relational, SQL, psql CLI
+- MySQL/MariaDB: relational, SQL
+- MongoDB: document database, aggregation pipelines
+- Redis: key-value store, caching
+
+## Rules
+
+- Always use parameterized queries (prevent SQL injection)
+- Test migrations in non-production first
+- Include rollback scripts for every migration
+- Use EXPLAIN ANALYZE for query optimization
+- Follow least-privilege for database users
+- Back up before destructive operations
+- Index based on actual query patterns, not assumptions

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

@@ -0,0 +1,35 @@
+---
+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
+- Deployments fail or services become unhealthy
+
+## 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/devops/skills/devops/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: devops
+description: Deploy and manage cloud infrastructure with Docker, Kubernetes, Terraform, and CI/CD pipelines. Use when working with containers, orchestration, IaC, or cloud platforms.
+---
+
+# DevOps
+
+Activate this skill when working with infrastructure, containers, deployments, or cloud services.
+
+## When to Use
+
+- Building or modifying Dockerfiles and docker-compose configurations
+- Writing Terraform/OpenTofu modules and configurations
+- Configuring Kubernetes manifests, Helm charts, or Kustomize
+- Designing CI/CD pipelines (GitHub Actions, GitLab CI)
+- Managing cloud resources (AWS, GCP, Azure)
+- Implementing deployment strategies (blue-green, canary, rolling)
+
+## Core Practices
+
+- Infrastructure as Code: all infrastructure defined in version-controlled files
+- Immutable infrastructure: replace, never patch in place
+- GitOps: git as single source of truth for desired state
+- Least privilege: minimal permissions for all service accounts
+- Defense in depth: multiple security layers
+- Observability: metrics, logs, and traces for all services
+
+## Docker Guidelines
+
+- Use multi-stage builds to minimize image size
+- Pin base image versions (no `latest` tag)
+- Run as non-root user
+- Use `.dockerignore` to exclude unnecessary files
+- Order layers from least to most frequently changing
+- Scan images for vulnerabilities before pushing
+
+## Terraform Guidelines
+
+- Use modules for reusable components
+- Pin provider and module versions
+- Store state remotely with locking
+- Use `terraform plan` before every apply
+- Tag all resources for cost tracking
+- Never store secrets in state files
+
+## Kubernetes Guidelines
+
+- Set resource requests and limits on all containers
+- Use namespaces for environment isolation
+- Implement health checks (liveness, readiness, startup probes)
+- Use network policies to restrict pod communication
+- Store secrets in external secret managers (not in manifests)
+- Use pod disruption budgets for availability

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

@@ -0,0 +1,32 @@
+---
+name: docs-seeker
+description: Search technical documentation using automated scripts to find relevant library, framework, or tool documentation. Use when you need official docs for a specific technology.
+---
+
+# Docs Seeker
+
+Activate this skill when you need to find and reference technical documentation.
+
+## When to Use
+
+- Looking up API references for a library or framework
+- Finding configuration options for a tool
+- Checking compatibility or version requirements
+- Understanding best practices from official sources
+- Verifying behavior described in documentation
+
+## Process
+
+1. Identify the technology and version
+2. Search official documentation sources
+3. Check llms.txt and context7.com for AI-friendly docs
+4. Extract relevant sections
+5. Summarize findings with source links
+
+## Rules
+
+- Always prefer official documentation over third-party sources
+- Include version numbers in all references
+- Verify information is current (check publish dates)
+- Provide direct links to source material
+- Note when documentation is incomplete or ambiguous

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

@@ -0,0 +1,32 @@
+---
+name: frontend-design
+description: Create production-grade frontend interfaces with high design quality. Use when building dashboards, admin panels, or monitoring UIs.
+---
+
+# Frontend Design
+
+Activate this skill when creating UI components or pages that need visual design decisions.
+
+## When to Use
+
+- Building monitoring dashboards or admin panels
+- Creating status pages or deployment UIs
+- Designing configuration interfaces
+- Implementing responsive layouts
+
+## Design Principles
+
+- Mobile-first responsive design
+- Visual hierarchy through typography and spacing
+- Consistent spacing using 4px/8px grid system
+- Accessible color contrast (WCAG 2.1 AA minimum)
+- Progressive disclosure of complex information
+
+## Rules
+
+- Use semantic HTML elements for structure
+- Ensure 4.5:1 contrast ratio for normal text
+- Touch targets minimum 44x44px on mobile
+- Respect prefers-reduced-motion for animations
+- Test across breakpoints before considering complete
+- Never use color as the sole indicator of state

package/dist/presets/devops/skills/kubernetes-ops/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: kubernetes-ops
+description: Operate and troubleshoot Kubernetes clusters, workloads, and networking. Use when deploying, scaling, or debugging Kubernetes resources.
+---
+
+# Kubernetes Operations
+
+Activate this skill when working with Kubernetes clusters and workloads.
+
+## When to Use
+
+- Deploying applications to Kubernetes
+- Troubleshooting pod failures or scheduling issues
+- Configuring networking (services, ingress, network policies)
+- Managing secrets and configuration
+- Scaling workloads and configuring autoscaling
+- Debugging container crashes or connectivity issues
+
+## Common Operations
+
+```bash
+# Check pod status and events
+kubectl get pods -n <namespace>
+kubectl describe pod <pod-name> -n <namespace>
+kubectl logs <pod-name> -n <namespace> --previous
+
+# Debug networking
+kubectl exec -it <pod> -- nslookup <service>
+kubectl get endpoints <service>
+kubectl get networkpolicies
+
+# Resource management
+kubectl top pods -n <namespace>
+kubectl get hpa
+```
+
+## Troubleshooting Flow
+
+1. Check pod status (Pending, CrashLoopBackOff, ImagePullBackOff)
+2. Read events with `kubectl describe`
+3. Check logs (current and previous container)
+4. Verify resource requests vs node capacity
+5. Check network policies and service endpoints
+6. Verify secrets and configmaps are mounted correctly
+
+## Rules
+
+- Always specify namespace explicitly
+- Use labels and selectors consistently
+- Set resource requests AND limits on all containers
+- Implement liveness, readiness, and startup probes
+- Use pod disruption budgets for critical workloads
+- Never use `kubectl edit` in production -- use GitOps
+- Store manifests in version control

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

@@ -0,0 +1,33 @@
+---
+name: mcp-builder
+description: Guide for creating MCP (Model Context Protocol) servers that enable LLMs to interact with external services. Use when building MCP 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 external API
+- Integrating infrastructure tools via MCP
+- Building custom tool interfaces for LLM agents
+- Wrapping CLI tools as MCP resources
+
+## Process
+
+1. Define the tools, resources, and prompts the server will expose
+2. Choose implementation language (Python with FastMCP or Node with MCP SDK)
+3. Implement tool handlers with proper input validation
+4. Add error handling and timeout management
+5. Test with MCP inspector
+6. Document tool schemas and usage examples
+
+## Rules
+
+- Keep tool descriptions clear and specific
+- Validate all inputs before processing
+- Handle errors gracefully with informative messages
+- Use proper typing for tool parameters
+- Document required environment variables
+- Test edge cases and error scenarios

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

@@ -0,0 +1,33 @@
+---
+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 or using MCP server integrations.
+
+## When to Use
+
+- Discovering available MCP tools and capabilities
+- Executing MCP tools programmatically
+- Troubleshooting MCP server connectivity
+- Configuring new MCP servers
+- Filtering tools for specific tasks
+
+## Process
+
+1. List configured MCP servers from `.kiro/settings/mcp.json`
+2. Check server availability and health
+3. Discover available tools, prompts, and resources
+4. Match capabilities to the current task
+5. Execute with proper parameters
+6. Handle errors and suggest alternatives
+
+## Rules
+
+- Always verify server availability before execution
+- Never expose credentials in tool output
+- Validate parameters against tool schema
+- Handle timeouts gracefully
+- Report failures with actionable guidance

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

@@ -0,0 +1,30 @@
+---
+name: media-processing
+description: Process multimedia files with FFmpeg and ImageMagick. Use when converting formats, encoding video, manipulating images, or optimizing media files.
+---
+
+# Media Processing
+
+Activate this skill when you need to manipulate media files.
+
+## When to Use
+
+- Converting media formats (video, audio, image)
+- Resizing, cropping, or optimizing images
+- Encoding video with specific codecs
+- Extracting audio from video
+- Batch processing media files
+- Creating thumbnails or previews
+
+## Tools
+
+- FFmpeg: video/audio encoding, conversion, streaming
+- ImageMagick: image manipulation, format conversion, effects
+
+## Rules
+
+- Use appropriate codecs for the target platform
+- Optimize for file size vs quality trade-off
+- Preserve metadata when appropriate
+- Test output on target devices/browsers
+- Use hardware acceleration when available

package/dist/presets/devops/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 create implementation plans or evaluate architectural approaches.
+---
+
+# Planning
+
+Activate this skill when creating implementation plans or evaluating technical approaches.
+
+## When to Use
+
+- Starting a new feature or system component
+- Evaluating multiple architectural approaches
+- Breaking down complex work into phases
+- Estimating effort and identifying risks
+- Creating migration or upgrade plans
+
+## Process
+
+1. Define success criteria and constraints
+2. Research relevant patterns and prior art
+3. Decompose into phases with clear deliverables
+4. Identify dependencies and critical path
+5. Assess risks and define mitigations
+6. Document the plan with actionable steps
+
+## Output Structure
+
+Create plans in `plans/YYYYMMDD-HHmm-plan-name/`:
+- `plan.md`: overview with phase list and status
+- `phase-XX-name.md`: per-phase details
+
+## Rules
+
+- Every task should be completable in 30 min to 2 hours
+- Include rollback strategy for risky phases
+- Identify what can be parallelized
+- List unresolved questions at the end
+- Apply YAGNI, KISS, DRY to every recommendation

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

@@ -0,0 +1,32 @@
+---
+name: problem-solving
+description: Apply systematic problem-solving techniques for complexity spirals, innovation blocks, recurring patterns, and scale uncertainty. Use when stuck or facing non-obvious challenges.
+---
+
+# Problem Solving
+
+Activate this skill when facing complex problems that resist straightforward solutions.
+
+## When to Use
+
+- Complexity spirals: problem keeps growing as you dig in
+- Innovation blocks: standard approaches are not working
+- Recurring patterns: same issue keeps appearing in different forms
+- Scale uncertainty: unclear how solution will behave at scale
+- Stuck: no clear path forward after initial attempts
+
+## Techniques
+
+1. Simplification Cascade: strip away complexity until core problem is visible
+2. Inversion: consider what would make the problem worse, then avoid those things
+3. Meta-pattern Recognition: identify the pattern behind recurring issues
+4. Scale Game: test solution at 1x, 10x, 100x to find breaking points
+5. Constraint Mapping: list all constraints, then question which are real vs assumed
+
+## Rules
+
+- Try the simplest approach first
+- If stuck after 3 attempts, change the approach entirely
+- Document what you tried and why it failed
+- Separate the problem from the solution space
+- Question assumptions before adding complexity

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

@@ -0,0 +1,39 @@
+---
+name: repomix
+description: Package code repositories into single AI-friendly files for analysis. Use when you need to understand a codebase structure or prepare context for analysis.
+---
+
+# Repomix
+
+Activate this skill when packaging codebases for analysis or generating repository summaries.
+
+## When to Use
+
+- Analyzing unfamiliar codebase structure
+- Creating repository snapshots for context
+- Generating documentation from code
+- Preparing codebase for security audit
+- Understanding third-party library internals
+
+## 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 as markdown
+repomix --style markdown
+```
+
+## Rules
+
+- Use include/exclude patterns to focus on relevant code
+- Output goes to `repomix-output.xml` by default
+- Use for understanding, not for copying code
+- Respect license terms of analyzed repositories

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

@@ -0,0 +1,34 @@
+---
+name: research
+description: Research and analyze technical solutions, evaluate trade-offs, and synthesize findings from multiple sources. Use before making technology decisions.
+---
+
+# Research
+
+Activate this skill when you need to investigate technologies, evaluate options, or gather information before making decisions.
+
+## When to Use
+
+- Evaluating competing technologies or approaches
+- Investigating unfamiliar tools or frameworks
+- Gathering best practices for a specific domain
+- Comparing cloud services or infrastructure options
+- Understanding security implications of a choice
+
+## Process
+
+1. Define the research question clearly
+2. Identify authoritative sources (official docs, RFCs, benchmarks)
+3. Gather data from multiple sources
+4. Cross-reference for accuracy
+5. Evaluate trade-offs in context of the project
+6. Synthesize into actionable recommendations
+
+## Rules
+
+- Prioritize official documentation over blog posts
+- State confidence level for each finding
+- Distinguish proven patterns from experimental approaches
+- Include version numbers and compatibility notes
+- Flag security concerns in recommendations
+- Do NOT implement -- only research and report

package/dist/presets/devops/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/devops/skills/skill-creator/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: skill-creator
+description: Guide for creating effective skills that extend agent capabilities with specialized knowledge, workflows, or tool integrations.
+---
+
+# 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
+- Designing skill structure for progressive disclosure
+- Integrating external tools into a skill workflow
+
+## Structure
+
+```
+skills/<skill-name>/
+  SKILL.md          Main skill file (concise, token-efficient)
+  references/       Detailed documentation (loaded on demand)
+  scripts/          Automation scripts
+  assets/           Static assets
+  tests/            Skill validation tests
+```
+
+## Rules
+
+- SKILL.md should be under 100 lines for token efficiency
+- Use references/ for detailed documentation
+- Include clear "When to Use" section
+- Define explicit process steps
+- Keep rules actionable and specific
+- Test skills before publishing