kiro-kit 0.1.0

package/dist/presets/data-ai/skills/tensorflow-keras/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: tensorflow-keras
+description: Build and train models with TensorFlow and Keras. Use when implementing production ML models, using tf.data pipelines, or deploying with TF Serving.
+---
+
+# TensorFlow / Keras
+
+Activate this skill when building models with TensorFlow or Keras.
+
+## When to Use
+
+- Building production-ready ML models
+- Implementing efficient data pipelines with tf.data
+- Deploying models with TensorFlow Serving
+- Using pre-trained models from TF Hub
+- Converting models to TFLite for edge deployment
+
+## Patterns
+
+```python
+import tensorflow as tf
+from tensorflow import keras
+
+model = keras.Sequential([
+    keras.layers.Dense(128, activation="relu"),
+    keras.layers.Dropout(0.3),
+    keras.layers.Dense(num_classes, activation="softmax"),
+])
+
+model.compile(
+    optimizer=keras.optimizers.Adam(1e-3),
+    loss="sparse_categorical_crossentropy",
+    metrics=["accuracy"],
+)
+
+model.fit(
+    train_ds,
+    validation_data=val_ds,
+    epochs=50,
+    callbacks=[
+        keras.callbacks.EarlyStopping(patience=5),
+        keras.callbacks.ModelCheckpoint("best_model.keras"),
+    ],
+)
+```
+
+## Rules
+
+- Use tf.data for efficient input pipelines
+- Prefer Keras API over raw TF ops
+- Enable mixed precision for GPU training
+- Use callbacks for checkpointing and early stopping
+- Profile with TensorBoard before optimizing
+

package/dist/presets/data-ai/specs/_templates/data-ai/design.md

@@ -0,0 +1,81 @@
+# Design: [Feature Name]
+
+## Architecture
+
+### Pipeline Overview
+
+```
+[Data Source] --> [Ingestion] --> [Preprocessing] --> [Feature Engineering]
+                                                          |
+                                                          v
+[Serving] <-- [Model Registry] <-- [Training] <-- [Feature Store]
+```
+
+### Data Flow
+
+Describe how data flows through the system:
+- Input sources and formats
+- Transformation steps
+- Output destinations
+- Caching and storage strategy
+
+## Data Design
+
+### Input Schema
+
+```python
+# Define expected input schema
+schema = {
+    "column_name": {"type": "float64", "nullable": False, "range": [0, 1]},
+    "category_col": {"type": "category", "values": ["A", "B", "C"]},
+}
+```
+
+### Feature Engineering
+
+| Feature | Source | Transform | Type |
+|---------|--------|-----------|------|
+| [name] | [column] | [operation] | numeric/categorical |
+
+## Model Design
+
+### Architecture
+- Model type: [classification/regression/clustering/etc.]
+- Algorithm: [specific algorithm or architecture]
+- Input dimensions: [shape]
+- Output: [description]
+
+### Hyperparameters
+- Learning rate: ___
+- Batch size: ___
+- Epochs: ___
+- Regularization: ___
+
+## Evaluation Strategy
+
+- Primary metric: [metric name]
+- Secondary metrics: [list]
+- Validation approach: [k-fold/holdout/time-series split]
+- Baseline: [what to compare against]
+
+## Testing Strategy
+
+- Unit tests: data transformations, feature computation
+- Integration tests: pipeline end-to-end
+- Model tests: prediction sanity checks, invariance tests
+- Data tests: schema validation, distribution checks
+
+## Performance Considerations
+
+- Data loading optimization (chunked, lazy)
+- GPU utilization strategy
+- Memory management for large datasets
+- Caching strategy for repeated computations
+
+## Risks and Mitigations
+
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| Data drift | Model degradation | Monitoring + retraining |
+| [risk] | [impact] | [mitigation] |
+

package/dist/presets/data-ai/specs/_templates/data-ai/requirements.md

@@ -0,0 +1,49 @@
+# Requirements: [Feature Name]
+
+## Overview
+
+Brief description of the data/ML feature and its purpose.
+
+## User Stories
+
+- As a data scientist, I want to [action] so that [benefit]
+- As an ML engineer, I want to [action] so that [benefit]
+
+## Functional Requirements
+
+### Data
+- [ ] Input data sources identified and accessible
+- [ ] Data schema defined and validated
+- [ ] Missing value handling strategy documented
+- [ ] Data volume and refresh frequency specified
+
+### Model/Pipeline
+- [ ] [Describe model or pipeline behavior]
+- [ ] [Describe input/output contract]
+- [ ] [Describe performance requirements]
+
+### Reproducibility
+- [ ] Random seeds documented
+- [ ] Environment dependencies pinned
+- [ ] Data versioning in place
+- [ ] Configuration externalized (no hardcoded values)
+
+## Non-Functional Requirements
+
+- [ ] Training completes within [time] on [hardware]
+- [ ] Inference latency under [X]ms at p95
+- [ ] Memory usage under [X]GB during training
+- [ ] Pipeline idempotent (safe to re-run)
+
+## Success Metrics
+
+- [ ] [Metric name] >= [threshold] (e.g., F1 >= 0.85)
+- [ ] [Metric name] <= [threshold] (e.g., latency <= 100ms)
+- [ ] [Baseline comparison] (e.g., +5% over current model)
+
+## Acceptance Criteria
+
+1. [Specific, testable criterion]
+2. [Specific, testable criterion]
+3. [Specific, testable criterion]
+

package/dist/presets/data-ai/specs/_templates/data-ai/tasks.md

@@ -0,0 +1,50 @@
+# Tasks: [Feature Name]
+
+## Phase 1: Data Preparation
+
+- [ ] 1.1 Identify and access data sources
+- [ ] 1.2 Define input/output schemas
+- [ ] 1.3 Implement data loading and validation
+- [ ] 1.4 Exploratory data analysis
+- [ ] 1.5 Document data quality findings
+
+## Phase 2: Feature Engineering
+
+- [ ] 2.1 Implement feature computation pipeline
+- [ ] 2.2 Handle missing values and outliers
+- [ ] 2.3 Create train/validation/test splits
+- [ ] 2.4 Validate feature distributions
+- [ ] 2.5 Write unit tests for transformations
+
+## Phase 3: Model Development
+
+- [ ] 3.1 Implement baseline model
+- [ ] 3.2 Set up experiment tracking
+- [ ] 3.3 Train and evaluate initial model
+- [ ] 3.4 Hyperparameter tuning
+- [ ] 3.5 Compare against baseline metrics
+
+## Phase 4: Pipeline Integration
+
+- [ ] 4.1 Wrap training in reproducible pipeline
+- [ ] 4.2 Add data validation checks
+- [ ] 4.3 Implement model versioning
+- [ ] 4.4 Create pipeline configuration
+- [ ] 4.5 Write integration tests
+
+## Phase 5: Evaluation and Documentation
+
+- [ ] 5.1 Final model evaluation on test set
+- [ ] 5.2 Generate evaluation report with visualizations
+- [ ] 5.3 Document model decisions and trade-offs
+- [ ] 5.4 Create model card with limitations
+- [ ] 5.5 Update project documentation
+
+## Phase 6: Deployment (if applicable)
+
+- [ ] 6.1 Create serving endpoint
+- [ ] 6.2 Implement input validation
+- [ ] 6.3 Set up monitoring and alerting
+- [ ] 6.4 Load testing and performance verification
+- [ ] 6.5 Rollback plan documentation
+

package/dist/presets/data-ai/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/data-ai/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/data-ai/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/data-ai/steering/ml-patterns.md

@@ -0,0 +1,75 @@
+---
+inclusion: always
+description: Machine learning patterns for experiment tracking, model lifecycle, data validation, and reproducibility.
+---
+
+# ML Patterns
+
+## Experiment Tracking
+
+- Log all hyperparameters, metrics, and artifacts
+- Use MLflow or Weights and Biases for tracking
+- Tag experiments with meaningful names and descriptions
+- Record git commit hash with each run
+- Store model configs as YAML alongside artifacts
+
+## Reproducibility
+
+- Set random seeds explicitly (numpy, torch, python random)
+- Pin all dependency versions in lock files
+- Use DVC for data versioning (large files outside git)
+- Document hardware requirements (GPU type, memory)
+- Store environment info with experiment results
+
+## Data Validation
+
+- Validate schema on data ingestion (pandera or great_expectations)
+- Check for nulls, duplicates, and out-of-range values
+- Monitor data drift between training and serving
+- Log data statistics (mean, std, distribution) per feature
+- Version datasets with checksums
+
+## Model Lifecycle
+
+```
+Raw Data -> Preprocessing -> Feature Engineering -> Training -> Evaluation -> Registry -> Serving
+```
+
+- Separate training from inference code paths
+- Use model registry for versioned model storage
+- Implement A/B testing for model comparison
+- Monitor model performance in production
+- Set up automated retraining triggers
+
+## Feature Engineering
+
+- Build features as pure functions (input -> output)
+- Document feature semantics and business meaning
+- Use feature stores for shared feature computation
+- Version feature definitions alongside model code
+- Test feature pipelines with known transformations
+
+## Evaluation
+
+- Define metrics before training (not after)
+- Use stratified splits for classification tasks
+- Report confidence intervals, not just point estimates
+- Test on held-out data never seen during development
+- Check for bias across demographic groups
+- Compare against meaningful baselines
+
+## Configuration
+
+- Use YAML or TOML for experiment configs
+- Separate model config from infrastructure config
+- Support config inheritance (base + override)
+- Validate configs with pydantic or dataclasses
+- Never hardcode hyperparameters in source code
+
+## Error Handling
+
+- Catch and log OOM errors with context
+- Implement checkpointing for long training runs
+- Graceful degradation on GPU unavailability
+- Validate model outputs before serving (NaN check, range check)
+- Alert on training divergence (loss explosion)

package/dist/presets/data-ai/steering/python-conventions.md

@@ -0,0 +1,78 @@
+---
+inclusion: always
+description: Python coding conventions for data science and ML projects including typing, project structure, and dependency management.
+---
+
+# Python Conventions
+
+## Project Structure
+
+```
+src/
+  data/               Data loading and preprocessing
+  features/           Feature engineering pipelines
+  models/             Model definitions and training
+  evaluation/         Metrics and evaluation logic
+  pipelines/          Orchestration and DAGs
+  utils/              Shared utilities
+notebooks/            Jupyter notebooks (exploration only)
+tests/                Test suite
+data/
+  raw/                Immutable raw data
+  processed/          Cleaned and transformed data
+  features/           Feature stores
+models/               Serialized model artifacts
+configs/              YAML/TOML configuration files
+```
+
+## Typing Rules
+
+- Use type hints on all function signatures
+- Use `typing` module for complex types (Optional, Union, Literal)
+- Use `TypedDict` for structured dictionaries
+- Prefer `list[str]` over `List[str]` (Python 3.10+)
+- Use `numpy.typing.NDArray` for array annotations
+- Use `pandas.DataFrame` type annotations where applicable
+
+## Naming Conventions
+
+- Modules: snake_case (`feature_engineering.py`)
+- Classes: PascalCase (`DataPipeline`)
+- Functions: snake_case (`compute_features`)
+- Constants: UPPER_SNAKE_CASE (`MAX_EPOCHS`)
+- Private: leading underscore (`_internal_helper`)
+- Type aliases: PascalCase (`FeatureMatrix = NDArray[np.float64]`)
+
+## Dependencies
+
+- Use `pyproject.toml` for project metadata and dependencies
+- Pin exact versions in production (`torch==2.1.0`)
+- Use version ranges in libraries (`numpy>=1.24,<2.0`)
+- Separate dev dependencies from production
+- Use `uv` or `pip-tools` for lock files
+
+## Code Style
+
+- Follow PEP 8 with 88-char line length (Black formatter)
+- Use `ruff` for linting (replaces flake8, isort, pyflakes)
+- Docstrings: Google style for all public functions
+- Imports: stdlib, third-party, local (separated by blank lines)
+- Prefer pathlib.Path over os.path
+- Use dataclasses or pydantic for structured data
+
+## Testing
+
+- Use pytest as test runner
+- Fixtures for shared test data and model instances
+- Parametrize tests for multiple input scenarios
+- Use hypothesis for property-based testing
+- Test data transformations with known input/output pairs
+- Mock external services (APIs, databases) in unit tests
+
+## Notebooks
+
+- Notebooks are for exploration and visualization only
+- Production code must live in `src/` modules
+- Clear outputs before committing notebooks
+- Use `nbstripout` as pre-commit hook
+- Number notebooks for ordering (`01-eda.ipynb`)

package/dist/presets/data-ai/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/data-ai/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/data-ai/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
+- Component + Styles + Tests: parallel work on different aspects of same feature
+- Ensure no file conflicts or shared resource contention
+- Plan integration points before parallel execution begins

package/dist/presets/data-ai/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/devops/.env.example

@@ -0,0 +1,36 @@
+# 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>
+
+# Cloud Provider Credentials
+# AWS_ACCESS_KEY_ID=<your-aws-access-key>
+# AWS_SECRET_ACCESS_KEY=<your-aws-secret-key>
+# AWS_DEFAULT_REGION=us-east-1
+
+# GCP_PROJECT_ID=<your-gcp-project-id>
+# GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
+
+# AZURE_SUBSCRIPTION_ID=<your-azure-subscription-id>
+# AZURE_TENANT_ID=<your-azure-tenant-id>
+
+# Container Registry
+# DOCKER_REGISTRY=<your-registry-url>
+# DOCKER_USERNAME=<your-username>
+# DOCKER_PASSWORD=<your-password>
+
+# Kubernetes
+# KUBECONFIG=/path/to/.kube/config
+# K8S_NAMESPACE=default
+
+# Terraform
+# TF_VAR_environment=development
+# TF_CLOUD_TOKEN=<your-terraform-cloud-token>
+
+# Application environment
+# NODE_ENV=development

package/dist/presets/devops/.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/devops/README.md

@@ -0,0 +1,57 @@
+# DevOps Preset
+
+A comprehensive kit for Docker, Kubernetes, Terraform, and CI/CD infrastructure engineering. Includes agents, skills, commands, hooks, workflows, and steering files tailored for modern DevOps practices.
+
+## Focus Areas
+
+- Docker containerization and multi-stage builds
+- Kubernetes orchestration and Helm charts
+- Terraform/OpenTofu infrastructure as code
+- CI/CD pipeline design (GitHub Actions, GitLab CI)
+- Cloud platforms (AWS, GCP, Azure)
+- Monitoring, observability, and alerting
+- Security scanning and compliance
+- GitOps workflows and deployment strategies
+
+## Structure
+
+```
+devops/
+  manifest.json          Preset manifest
+  README.md              This file
+  agents/                20 agent definitions
+  skills/                21 skill folders
+  commands/              29+ command files (including devops/ category)
+  hooks/                 Cross-platform hook scripts (8 hooks)
+  steering/              Docker/Infrastructure conventions
+  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/       DevOps spec templates
+  docs/                  Documentation templates (code-standards, architecture, roadmap)
+```
+
+## Minimum Thresholds
+
+- agents: 20
+- skills: 21
+- commands: 29
+- hooks: 8
+- workflows: 4
+
+## Recommended Usage
+
+```bash
+npx kiro-kit init --preset devops
+```
+
+Best suited for projects using:
+- Docker and container orchestration
+- Kubernetes (EKS, GKE, AKS)
+- Terraform or OpenTofu for IaC
+- GitHub Actions or GitLab CI
+- Cloud-native architecture