kiro-kit 0.1.0

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

@@ -0,0 +1,24 @@
+---
+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 skill. Copy this directory to create a new skill.
+
+## When to Use
+
+- [Describe when this skill should be activated]
+
+## Process
+
+1. [Step 1]
+2. [Step 2]
+3. [Step 3]
+
+## Rules
+
+- [Rule 1]
+- [Rule 2]
+- [Rule 3]

package/dist/presets/devops/skills/terraform-modules/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: terraform-modules
+description: Design and implement reusable Terraform modules with proper interfaces, testing, and documentation. Use when creating or refactoring infrastructure modules.
+---
+
+# Terraform Modules
+
+Activate this skill when designing or implementing Terraform modules.
+
+## When to Use
+
+- Creating reusable infrastructure components
+- Refactoring inline resources into modules
+- Designing module interfaces (variables, outputs)
+- Testing infrastructure code
+- Publishing modules to registries
+
+## Module Structure
+
+```
+modules/<module-name>/
+  main.tf           Primary resource definitions
+  variables.tf      Input variables with descriptions and validation
+  outputs.tf        Output values for consumers
+  versions.tf       Provider and Terraform version constraints
+  README.md         Usage documentation with examples
+  examples/         Example configurations
+  tests/            Terratest or terraform test files
+```
+
+## Design Principles
+
+- Single responsibility: one module, one concern
+- Sensible defaults: work out of the box with minimal config
+- Explicit interfaces: all inputs documented with types and validation
+- Composable: modules should compose with other modules cleanly
+- Testable: include examples that can be used as integration tests
+
+## Rules
+
+- Pin provider versions in versions.tf
+- Add validation blocks to variables where appropriate
+- Use `terraform fmt` before committing
+- Include at least one working example
+- Document all variables and outputs
+- Use data sources over hardcoded values
+- Never hardcode account IDs, regions, or environment names

package/dist/presets/devops/skills/web-frameworks/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: web-frameworks
+description: Build web applications with modern frameworks (Next.js, Express, Fastify). Use when implementing web services or server-side applications.
+---
+
+# Web Frameworks
+
+Activate this skill when building web applications or services.
+
+## When to Use
+
+- Setting up web application projects
+- Implementing server-side rendering
+- Building API services with Express or Fastify
+- Configuring build tools and bundlers
+- Managing monorepo structures with Turborepo
+
+## Frameworks
+
+- Next.js: React framework with SSR/SSG/ISR
+- Express/Fastify: Node.js HTTP servers
+- Turborepo: monorepo management and build orchestration
+
+## Rules
+
+- Follow framework conventions for file structure
+- Use environment variables for configuration
+- Implement proper error handling middleware
+- Configure security headers (CORS, CSP, HSTS)
+- Optimize for production builds
+- Use TypeScript for type safety

package/dist/presets/devops/specs/_templates/devops/design.md

@@ -0,0 +1,87 @@
+# Design: [Feature Name]
+
+## Architecture
+
+### Infrastructure Diagram
+
+```
+[Load Balancer]
+  |
+  +-- [Service A] -- [Database]
+  |
+  +-- [Service B] -- [Cache]
+```
+
+### Component Overview
+
+Describe each infrastructure component and its role:
+- Compute: type, sizing, scaling strategy
+- Storage: type, retention, backup policy
+- Networking: VPC, subnets, security groups
+- Monitoring: metrics, alerts, dashboards
+
+## Infrastructure as Code
+
+### Module Structure
+
+```
+infrastructure/
+  modules/
+    [module-name]/
+      main.tf
+      variables.tf
+      outputs.tf
+  environments/
+    dev/
+    staging/
+    production/
+```
+
+### Key Decisions
+
+- State backend: [S3/GCS/Azure Blob]
+- Secret management: [AWS Secrets Manager/Vault/etc]
+- Container orchestration: [EKS/GKE/AKS/ECS]
+- CI/CD platform: [GitHub Actions/GitLab CI/etc]
+
+## Deployment Strategy
+
+- [ ] Rolling update
+- [ ] Blue-green deployment
+- [ ] Canary release
+- [ ] Feature flags
+
+### Rollback Plan
+
+Describe how to revert if deployment fails.
+
+## Monitoring and Observability
+
+### SLIs and SLOs
+
+| Indicator | Target | Measurement |
+|-----------|--------|-------------|
+| Availability | 99.9% | Uptime checks |
+| Latency (p99) | < 500ms | APM metrics |
+| Error rate | < 0.1% | Log analysis |
+
+### Alerting
+
+- P1 (page): [conditions]
+- P2 (notify): [conditions]
+- P3 (ticket): [conditions]
+
+## Security Considerations
+
+- Network isolation approach
+- Encryption strategy
+- Access control model
+- Compliance requirements
+
+## Cost Estimate
+
+| Resource | Monthly Cost | Notes |
+|----------|-------------|-------|
+| Compute | $X | [sizing rationale] |
+| Storage | $X | [retention policy] |
+| Network | $X | [traffic estimate] |

package/dist/presets/devops/specs/_templates/devops/requirements.md

@@ -0,0 +1,42 @@
+# Requirements: [Feature Name]
+
+## Overview
+
+Brief description of the infrastructure feature and its purpose.
+
+## User Stories
+
+- As a [platform engineer/SRE/developer], I want to [action] so that [benefit]
+
+## Functional Requirements
+
+### Infrastructure
+- [ ] Resources provisioned correctly in target environment
+- [ ] Configuration parameterized for multi-environment support
+- [ ] State managed remotely with proper locking
+- [ ] Tagging applied for cost tracking and ownership
+
+### Reliability
+- [ ] Health checks configured for all services
+- [ ] Auto-scaling rules defined for variable load
+- [ ] Backup and recovery procedures documented
+- [ ] Failover tested and documented
+
+### Security
+- [ ] Least-privilege IAM policies applied
+- [ ] Encryption at rest and in transit enabled
+- [ ] Network segmentation implemented
+- [ ] Secrets managed via external secret store
+
+## Non-Functional Requirements
+
+- [ ] Deployment completes in under 10 minutes
+- [ ] Recovery Time Objective (RTO): [specify]
+- [ ] Recovery Point Objective (RPO): [specify]
+- [ ] 99.9% availability SLO for production
+
+## Acceptance Criteria
+
+1. [Specific, testable criterion]
+2. [Specific, testable criterion]
+3. [Specific, testable criterion]

package/dist/presets/devops/specs/_templates/devops/tasks.md

@@ -0,0 +1,46 @@
+# Tasks: [Feature Name]
+
+## Phase 1: Foundation
+
+- [ ] 1.1 Create Terraform module structure
+- [ ] 1.2 Define variables and outputs interface
+- [ ] 1.3 Configure remote state backend
+- [ ] 1.4 Set up CI/CD pipeline for infrastructure
+
+## Phase 2: Core Infrastructure
+
+- [ ] 2.1 Provision networking (VPC, subnets, security groups)
+- [ ] 2.2 Set up compute resources with auto-scaling
+- [ ] 2.3 Configure storage and database resources
+- [ ] 2.4 Implement IAM roles and policies
+- [ ] 2.5 Configure DNS and load balancing
+
+## Phase 3: Application Deployment
+
+- [ ] 3.1 Build container images with multi-stage Dockerfile
+- [ ] 3.2 Push images to container registry
+- [ ] 3.3 Create Kubernetes manifests or ECS task definitions
+- [ ] 3.4 Deploy application with health checks
+- [ ] 3.5 Configure secrets injection
+
+## Phase 4: Observability
+
+- [ ] 4.1 Set up metrics collection (Prometheus/CloudWatch)
+- [ ] 4.2 Configure alerting rules with runbooks
+- [ ] 4.3 Create operational dashboards
+- [ ] 4.4 Implement structured logging
+- [ ] 4.5 Set up distributed tracing
+
+## Phase 5: Security and Compliance
+
+- [ ] 5.1 Run security scan on infrastructure code
+- [ ] 5.2 Validate network policies
+- [ ] 5.3 Verify encryption configuration
+- [ ] 5.4 Document compliance status
+
+## Phase 6: Testing and Validation
+
+- [ ] 6.1 Run infrastructure integration tests
+- [ ] 6.2 Perform load testing
+- [ ] 6.3 Test failover and recovery procedures
+- [ ] 6.4 Validate monitoring and alerting

package/dist/presets/devops/statusline.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+// Statusline: outputs git branch + project name + time on one line.
+
+const { execSync } = require('child_process');
+const path = require('path');
+
+let branch = '';
+try {
+  branch = execSync('git rev-parse --abbrev-ref HEAD', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+} catch (e) {
+  // Not a git repo
+}
+
+const projectName = path.basename(process.cwd());
+const time = new Date().toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+
+const parts = [];
+if (branch) parts.push(branch);
+parts.push(projectName);
+parts.push(time);
+
+process.stdout.write(parts.join(' | ') + '\n');

package/dist/presets/devops/statusline.ps1

@@ -0,0 +1,16 @@
+# Statusline: outputs git branch + project name + time on one line.
+# Gracefully omits git branch if not a git repository.
+
+$Branch = ''
+try {
+    $Branch = (git rev-parse --abbrev-ref HEAD 2>$null)
+} catch {}
+
+$Project = Split-Path -Leaf (Get-Location)
+$Time = Get-Date -Format 'HH:mm'
+
+if ($Branch) {
+    Write-Output "$Branch | $Project | $Time"
+} else {
+    Write-Output "$Project | $Time"
+}

package/dist/presets/devops/statusline.sh

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+# Statusline: outputs git branch + project name + time on one line.
+# Gracefully omits git branch if not a git repository.
+
+BRANCH=""
+if git rev-parse --abbrev-ref HEAD >/dev/null 2>&1; then
+  BRANCH=$(git rev-parse --abbrev-ref HEAD)
+fi
+
+PROJECT=$(basename "$PWD")
+TIME=$(date +"%H:%M")
+
+if [ -n "$BRANCH" ]; then
+  echo "$BRANCH | $PROJECT | $TIME"
+else
+  echo "$PROJECT | $TIME"
+fi

package/dist/presets/devops/steering/docker-conventions.md

@@ -0,0 +1,45 @@
+---
+inclusion: always
+description: Docker and container conventions for building secure, efficient container images and compose configurations.
+---
+
+# Docker Conventions
+
+## Dockerfile Standards
+
+- Use multi-stage builds to separate build and runtime
+- Pin base image versions with SHA digest for reproducibility
+- Run as non-root user (create dedicated user in Dockerfile)
+- Order layers from least to most frequently changing
+- Combine RUN commands to reduce layer count
+- Use `.dockerignore` to exclude unnecessary files
+
+## Image Selection
+
+- Production: use distroless or alpine-based images
+- Build stage: use full SDK images for compilation
+- Never use `latest` tag in production Dockerfiles
+- Prefer official images from Docker Hub or verified publishers
+
+## Security
+
+- Do not store secrets in image layers (use build secrets or runtime injection)
+- Drop all capabilities, add only what is needed
+- Use read-only root filesystem where possible
+- Scan images with trivy or grype before pushing to registry
+- Set `HEALTHCHECK` instruction for orchestrator integration
+
+## Docker Compose
+
+- Use named volumes for persistent data
+- Define resource limits (memory, CPU) for all services
+- Use environment files (`.env`) for configuration
+- Define explicit networks for service isolation
+- Use `depends_on` with health check conditions
+
+## Naming
+
+- Images: `<registry>/<org>/<service>:<version>`
+- Containers: `<project>-<service>-<instance>`
+- Volumes: `<project>-<service>-data`
+- Networks: `<project>-<tier>` (frontend, backend, data)

package/dist/presets/devops/steering/infrastructure-patterns.md

@@ -0,0 +1,58 @@
+---
+inclusion: always
+description: Infrastructure as Code patterns and conventions for Terraform, Kubernetes, and cloud resource management.
+---
+
+# Infrastructure Patterns
+
+## Terraform Conventions
+
+- One module per logical resource group (networking, compute, database)
+- Use `variables.tf`, `outputs.tf`, `main.tf`, `versions.tf` per module
+- Pin provider versions in `versions.tf`
+- Use `terraform fmt` and `terraform validate` before commits
+- Store state remotely with locking enabled
+- Use workspaces or directory structure for environment separation
+- Tag all resources: environment, team, cost-center, managed-by
+
+## Kubernetes Manifests
+
+- Use namespaces for environment and team isolation
+- Set resource requests AND limits on all containers
+- Implement all three probe types: liveness, readiness, startup
+- Use ConfigMaps for non-sensitive configuration
+- Use external secret managers for sensitive data
+- Apply network policies to restrict pod-to-pod communication
+- Use pod disruption budgets for critical workloads
+
+## File Organization
+
+```
+infrastructure/
+  modules/             Reusable Terraform modules
+    networking/
+    compute/
+    database/
+  environments/        Environment-specific configurations
+    dev/
+    staging/
+    production/
+  kubernetes/          K8s manifests
+    base/              Kustomize base
+    overlays/          Environment overlays
+  scripts/             Operational scripts
+```
+
+## Naming Conventions
+
+- Resources: `<project>-<environment>-<resource-type>`
+- Terraform variables: snake_case (`instance_type`)
+- Kubernetes resources: kebab-case (`my-service`)
+- Helm values: camelCase (`replicaCount`)
+
+## Environment Promotion
+
+- dev: auto-deploy on merge to main
+- staging: manual trigger or scheduled
+- production: manual approval required, canary first
+- All environments use same IaC with different variable values

package/dist/presets/devops/workflows/development-rules.md

@@ -0,0 +1,34 @@
+# Development Rules
+
+Follow these principles: YAGNI (You Aren't Gonna Need It), KISS (Keep It Simple, Stupid), DRY (Don't Repeat Yourself).
+
+## General
+
+- Use kebab-case for file names with meaningful descriptive names
+- Keep individual code files under 200 lines
+- Split large files into smaller, focused components/modules
+- Use composition over inheritance for complex components
+- Extract utility functions into separate modules
+- Create dedicated service classes for business logic
+
+## Code Quality
+
+- Prioritize functionality and readability over strict style enforcement
+- Use try-catch error handling and cover security standards
+- No syntax errors -- code must be compilable at all times
+- Follow the codebase structure and code standards in `docs/`
+
+## Pre-commit Rules
+
+- Run linting before commit
+- Run tests before push
+- Keep commits focused on actual code changes
+- Do NOT commit confidential information (dotenv files, API keys, credentials)
+- Use conventional commit format
+
+## Implementation
+
+- Write clean, readable, maintainable code
+- Follow established architectural patterns
+- Handle edge cases and error scenarios
+- Do NOT create new enhanced files -- update existing files directly

package/dist/presets/devops/workflows/documentation-management.md

@@ -0,0 +1,24 @@
+# Documentation Management
+
+## Automatic Updates Required
+
+- After feature implementation: update roadmap progress and changelog
+- After major milestones: review and adjust roadmap phases
+- After bug fixes: document fixes in changelog with severity and impact
+- After security updates: record security improvements and version updates
+
+## Documentation Triggers
+
+Update documentation when:
+- A development phase status changes
+- Major features are implemented or released
+- Significant bugs are resolved or security patches applied
+- Project timeline or scope adjustments are made
+- External dependencies or breaking changes occur
+
+## Update Protocol
+
+1. Before updates: read current roadmap and changelog status
+2. During updates: maintain version consistency and proper formatting
+3. After updates: verify links, dates, and cross-references
+4. Quality check: ensure updates align with actual implementation progress

package/dist/presets/devops/workflows/orchestration-protocol.md

@@ -0,0 +1,18 @@
+# Orchestration Protocol
+
+## Sequential Chaining
+
+Chain agents when tasks have dependencies:
+- Planning then Implementation then Testing then Review: for feature development
+- Research then Design then Code then Documentation: for new components
+- Each agent completes fully before the next begins
+- Pass context and outputs between agents in the chain
+
+## Parallel Execution
+
+Spawn multiple agents simultaneously for independent tasks:
+- Code + Tests + Docs: when implementing separate, non-conflicting components
+- Multiple Feature Branches: different agents working on isolated features
+- Infrastructure + Application + Monitoring: parallel work on different layers
+- Ensure no file conflicts or shared resource contention
+- Plan integration points before parallel execution begins

package/dist/presets/devops/workflows/primary-workflow.md

@@ -0,0 +1,33 @@
+# Primary Workflow
+
+Follow this cycle for all implementation work: Plan, Implement, Test, Review.
+
+## 1. Planning
+
+- Analyze requirements and break into concrete tasks
+- Research relevant technical topics before implementation
+- Create implementation plan with TODO items
+
+## 2. Implementation
+
+- Write clean, readable, maintainable code
+- Follow established architectural patterns
+- Implement features according to specifications
+- Handle edge cases and error scenarios
+- After modifying code, run compile/build to check for errors
+
+## 3. Testing
+
+- Write comprehensive unit tests for new functionality
+- Ensure high code coverage on critical paths
+- Test error scenarios and edge cases
+- Validate performance requirements
+- Do not use mocks or fake data just to pass tests
+
+## 4. Review
+
+- Review code for standards compliance
+- Check for security concerns
+- Verify documentation is updated
+- Ensure backward compatibility
+- Confirm no regressions introduced

package/dist/presets/frontend/.env.example

@@ -0,0 +1,19 @@
+# Project-level environment variables
+# Copy this file to .env and fill in your values.
+
+# Workspace root path (auto-detected by CLI)
+# WORKSPACE_ROOT=/path/to/project
+
+# API keys for external services
+# OPENAI_API_KEY=<your-openai-api-key>
+# ANTHROPIC_API_KEY=<your-anthropic-api-key>
+
+# Next.js specific
+# NEXT_PUBLIC_API_URL=http://localhost:3000/api
+# NEXT_PUBLIC_SITE_URL=http://localhost:3000
+
+# Analytics (optional)
+# NEXT_PUBLIC_GA_ID=<your-google-analytics-id>
+
+# Application environment
+# NODE_ENV=development

package/dist/presets/frontend/.mcp.json.example

@@ -0,0 +1,30 @@
+{
+  "mcpServers": {
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "${WORKSPACE_ROOT}"]
+    },
+    "git": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-git", "--repository", "${WORKSPACE_ROOT}"]
+    },
+    "docs-seeker": {
+      "command": "npx",
+      "args": ["-y", "@mcp/docs-seeker"],
+      "env": {
+        "DOCS_PATH": "${WORKSPACE_ROOT}/docs"
+      }
+    },
+    "playwright": {
+      "command": "npx",
+      "args": ["-y", "@playwright/mcp-server"],
+      "env": {
+        "BROWSER": "chromium"
+      }
+    },
+    "fetch": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-fetch"]
+    }
+  }
+}

package/dist/presets/frontend/README.md

@@ -0,0 +1,55 @@
+# Frontend Preset
+
+A comprehensive kit for React/Next.js + TypeScript frontend development. Includes agents, skills, commands, hooks, workflows, and steering files tailored for modern frontend engineering.
+
+## Focus Areas
+
+- React component architecture and patterns
+- Next.js App Router, Server Components, SSR/SSG/ISR
+- TypeScript strict mode and type safety
+- Tailwind CSS and component libraries (shadcn/ui, Radix)
+- Performance optimization (Core Web Vitals, bundle size)
+- Accessibility (WCAG 2.1 AA compliance)
+- Testing (Vitest, React Testing Library, Playwright)
+
+## Structure
+
+```
+frontend/
+  manifest.json          Preset manifest
+  README.md              This file
+  agents/                16 agent definitions
+  skills/                20+ skill folders
+  commands/              25+ command files (including frontend/ category)
+  hooks/                 Cross-platform hook scripts
+  steering/              React/Next.js conventions and patterns
+  workflows/             4 workflow files
+  settings.json          Kiro settings (statusLine, hooks)
+  statusline.js          Statusline script (Node, primary)
+  statusline.sh          Statusline script (bash fallback)
+  statusline.ps1         Statusline script (PowerShell fallback)
+  .mcp.json.example      MCP server config template
+  .env.example           Environment variables template
+  specs/_templates/       Frontend spec templates
+  docs/                  Documentation templates (code-standards, architecture, roadmap)
+```
+
+## Minimum Thresholds
+
+- agents: 16
+- skills: 20
+- commands: 29
+- hooks: 6
+- workflows: 4
+
+## Recommended Usage
+
+```bash
+npx kiro-kit init --preset frontend
+```
+
+Best suited for projects using:
+- React 18+ / Next.js 14+
+- TypeScript 5+
+- Tailwind CSS
+- pnpm or npm package management