kiro-kit 0.1.0

package/dist/presets/data-ai/commands/ml/tune.md

@@ -0,0 +1,18 @@
+---
+description: Run hyperparameter tuning with Optuna or grid search
+inclusion: manual
+argument-hint: "[config-path] [n-trials]"
+---
+
+## Arguments
+CONFIG: $1 (required, path to tuning config)
+TRIALS: $2 (default: 50, number of optimization trials)
+
+## Workflow
+1. Load tuning configuration with search spaces
+2. Initialize Optuna study or grid search
+3. Run optimization trials with cross-validation
+4. Log all trials to experiment tracker
+5. Report best parameters and score
+6. Save best model and configuration
+

package/dist/presets/data-ai/commands/pipeline/build.md

@@ -0,0 +1,18 @@
+---
+description: Build a data pipeline DAG from configuration
+inclusion: manual
+argument-hint: "[pipeline-config] [target]"
+---
+
+## Arguments
+CONFIG: $1 (required, path to pipeline config YAML)
+TARGET: $2 (default: all, specific pipeline stage to build)
+
+## Workflow
+1. Parse pipeline configuration
+2. Validate DAG structure (no cycles)
+3. Check data source availability
+4. Generate pipeline code (Airflow DAG or script)
+5. Run dry-run validation
+6. Report pipeline structure and dependencies
+

package/dist/presets/data-ai/commands/pipeline/run.md

@@ -0,0 +1,18 @@
+---
+description: Execute a data pipeline locally or trigger remote execution
+inclusion: manual
+argument-hint: "[pipeline-name] [mode]"
+---
+
+## Arguments
+PIPELINE: $1 (required, pipeline name or config path)
+MODE: $2 (default: local, options: local, dry-run, remote)
+
+## Workflow
+1. Load pipeline definition
+2. If dry-run: validate inputs and print execution plan
+3. If local: execute stages sequentially with logging
+4. If remote: trigger execution on orchestrator (Airflow/Prefect)
+5. Monitor progress and report stage completion
+6. Report final status and output locations
+

package/dist/presets/data-ai/commands/pipeline/validate.md

@@ -0,0 +1,17 @@
+---
+description: Validate pipeline configuration and data contracts
+inclusion: manual
+argument-hint: "[pipeline-config]"
+---
+
+## Arguments
+CONFIG: $1 (required, path to pipeline config)
+
+## Workflow
+1. Parse pipeline YAML/JSON configuration
+2. Validate DAG structure (no cycles, all refs resolve)
+3. Check data source connectivity
+4. Validate schema contracts between stages
+5. Verify output paths are writable
+6. Report validation results
+

package/dist/presets/data-ai/commands/plan/feature.md

@@ -0,0 +1,18 @@
+---
+description: Plan a new data/ML feature with research and task breakdown
+inclusion: manual
+argument-hint: "[feature-description]"
+---
+
+## Arguments
+FEATURE: $1 (required, description of the feature)
+
+## Workflow
+1. Research existing solutions and approaches
+2. Define success metrics and acceptance criteria
+3. Identify data requirements and availability
+4. Design approach with clear milestones
+5. Create task breakdown with estimates
+6. Document risks and compute requirements
+7. Save plan to `plans/` directory
+

package/dist/presets/data-ai/commands/plan/refactor.md

@@ -0,0 +1,18 @@
+---
+description: Plan a refactoring effort with impact analysis
+inclusion: manual
+argument-hint: "[refactor-scope]"
+---
+
+## Arguments
+SCOPE: $1 (required, what to refactor)
+
+## Workflow
+1. Analyze current code structure and dependencies
+2. Identify affected modules and tests
+3. Design target architecture
+4. Plan migration steps (incremental, not big-bang)
+5. Identify risks and rollback strategy
+6. Create task breakdown
+7. Save plan to `plans/` directory
+

package/dist/presets/data-ai/commands/release.md

@@ -0,0 +1,17 @@
+---
+description: Prepare a release with version bump, changelog, and package build
+inclusion: manual
+argument-hint: "[version-bump]"
+---
+
+## Arguments
+BUMP: $1 (default: patch, options: major, minor, patch)
+
+## Workflow
+1. Run full test suite and verify all pass
+2. Bump version in `pyproject.toml` or `setup.cfg`
+3. Update CHANGELOG.md with new version section
+4. Build package with `python -m build`
+5. Verify package with `twine check dist/*`
+6. Create git tag and commit
+

package/dist/presets/data-ai/commands/review/code.md

@@ -0,0 +1,17 @@
+---
+description: Review code changes for correctness, performance, and best practices
+inclusion: manual
+argument-hint: "[file-or-branch]"
+---
+
+## Arguments
+TARGET: $1 (default: staged changes, or specific file/branch)
+
+## Workflow
+1. Identify changed files (git diff or specified target)
+2. Review for correctness (logic errors, edge cases)
+3. Check data handling (leakage, validation, types)
+4. Verify test coverage for changes
+5. Check for security issues (credentials, injection)
+6. Report findings with severity levels
+

package/dist/presets/data-ai/commands/review/security.md

@@ -0,0 +1,18 @@
+---
+description: Security review focused on data handling and credentials
+inclusion: manual
+argument-hint: "[scope]"
+---
+
+## Arguments
+SCOPE: $1 (default: full project)
+
+## Workflow
+1. Scan for hardcoded credentials and API keys
+2. Check `.env` files are gitignored
+3. Verify data access controls and permissions
+4. Check for SQL injection in database queries
+5. Review dependency vulnerabilities (`pip audit`)
+6. Check model serving endpoints for auth
+7. Report findings with remediation steps
+

package/dist/presets/data-ai/commands/scout/ext.md

@@ -0,0 +1,17 @@
+---
+description: Scout codebase using external agentic tools (Gemini, OpenCode)
+inclusion: manual
+argument-hint: "[search-query] [scale]"
+---
+
+## Arguments
+QUERY: $1 (required, description of what to find)
+SCALE: $2 (default: 3, number of parallel agents)
+
+## Workflow
+1. Analyze search request and divide into parallel tasks
+2. Launch external agents (gemini/opencode) for each section
+3. Set 3-minute timeout per agent
+4. Collect and deduplicate results
+5. Present organized file list
+

package/dist/presets/data-ai/commands/scout.md

@@ -0,0 +1,17 @@
+---
+description: Scout the codebase to find relevant files for a task
+inclusion: manual
+argument-hint: "[search-query] [scale]"
+---
+
+## Arguments
+QUERY: $1 (required, description of what to find)
+SCALE: $2 (default: 3, number of parallel search agents)
+
+## Workflow
+1. Analyze the search request and identify key directories
+2. Divide codebase into logical sections for parallel searching
+3. Launch SCALE parallel agents to search different areas
+4. Synthesize results into organized file list
+5. Report findings grouped by category
+

package/dist/presets/data-ai/commands/skill/add.md

@@ -0,0 +1,17 @@
+---
+description: Add a new skill to the agent ecosystem
+inclusion: manual
+argument-hint: "[skill-name] [reference-or-script-prompt]"
+---
+
+## Arguments
+NAME: $1 (required, skill name in kebab-case)
+PROMPT: $2 (required, description of skill content)
+
+## Workflow
+1. Create skill directory at `skills/$NAME/`
+2. Generate SKILL.md with front-matter and instructions
+3. Add references/ directory if documentation is extensive
+4. Verify front-matter has required fields (name, description)
+5. Update skills/README.md with new entry
+

package/dist/presets/data-ai/commands/skill/create.md

@@ -0,0 +1,19 @@
+---
+description: Create a new skill from scratch with guided workflow
+inclusion: manual
+argument-hint: "[skill-name] [domain]"
+---
+
+## Arguments
+NAME: $1 (required, skill name in kebab-case)
+DOMAIN: $2 (required, domain area for the skill)
+
+## Workflow
+1. Research the domain for key concepts and patterns
+2. Define activation triggers (when should this skill activate?)
+3. Structure knowledge into concise instructions
+4. Create SKILL.md with front-matter
+5. Add references/ if domain is complex
+6. Test activation with sample prompts
+7. Update skills/README.md
+

package/dist/presets/data-ai/commands/skill/optimize.md

@@ -0,0 +1,18 @@
+---
+description: Optimize an existing skill for better activation and token efficiency
+inclusion: manual
+argument-hint: "[skill-name] [prompt]"
+---
+
+## Arguments
+SKILL: $1 (required, skill name to optimize)
+PROMPT: $2 (optional, specific optimization direction)
+
+## Workflow
+1. Read current SKILL.md content
+2. Analyze activation triggers and coverage
+3. Identify redundant or unclear sections
+4. Optimize for token efficiency while maintaining quality
+5. Verify front-matter is correct
+6. Report changes made
+

package/dist/presets/data-ai/commands/test.md

@@ -0,0 +1,17 @@
+---
+description: Run test suite with coverage reporting
+inclusion: manual
+argument-hint: "[test-path] [markers]"
+---
+
+## Arguments
+PATH: $1 (default: tests/)
+MARKERS: $2 (default: none, options: unit, integration, slow, gpu)
+
+## Workflow
+1. If MARKERS specified: run `pytest $PATH -m "$MARKERS" --cov`
+2. Otherwise: run `pytest $PATH --cov --cov-report=term-missing`
+3. Report coverage summary
+4. Highlight uncovered critical paths
+5. Suggest tests for uncovered code
+

package/dist/presets/data-ai/docs/code-standards.md

@@ -0,0 +1,89 @@
+# Code Standards
+
+## Python
+
+- Target Python 3.10+ (use modern syntax: `match`, `|` unions)
+- Type hints on all public functions and class methods
+- Use `ruff` for linting and formatting
+- Use `mypy` in strict mode for type checking
+- Docstrings: Google style for all public APIs
+
+## Project Structure
+
+```
+project-root/
+  src/
+    data/              Data loading and preprocessing
+    features/          Feature engineering modules
+    models/            Model definitions and training
+    pipelines/         Pipeline orchestration
+    utils/             Shared utilities
+  notebooks/           Exploratory analysis (numbered)
+  tests/
+    unit/              Fast, isolated tests
+    integration/       Pipeline integration tests
+  configs/             YAML configuration files
+  data/
+    raw/               Immutable source data
+    processed/         Cleaned, transformed data
+    features/          Feature store outputs
+  models/              Trained model artifacts
+  reports/             Generated analysis reports
+```
+
+## Naming
+
+- Files: snake_case (`feature_engineering.py`, `train_model.py`)
+- Classes: PascalCase (`DataLoader`, `ModelTrainer`)
+- Functions: snake_case (`load_dataset`, `compute_features`)
+- Constants: UPPER_SNAKE_CASE (`BATCH_SIZE`, `LEARNING_RATE`)
+- Configs: kebab-case YAML (`train-config.yaml`)
+
+## Data Handling
+
+- Never modify raw data files (immutable source)
+- Document data transformations with comments
+- Validate schemas at pipeline boundaries
+- Handle missing values explicitly (never silently drop)
+- Use `pathlib.Path` for all file paths
+
+## ML Code
+
+- Set random seeds for reproducibility (`seed_everything()`)
+- Separate data loading, preprocessing, training, evaluation
+- Log all experiments (params, metrics, artifacts)
+- Use configuration files over hardcoded values
+- Write tests for data transformations
+
+## Testing
+
+- Use `pytest` as test runner
+- Colocate unit tests in `tests/unit/`
+- Use fixtures for shared test data
+- Test data transformations with known inputs/outputs
+- Mark slow tests with `@pytest.mark.slow`
+- Mark GPU tests with `@pytest.mark.gpu`
+
+## Error Handling
+
+- Use custom exceptions for domain errors
+- Validate inputs at function boundaries
+- Log errors with context (data shape, config values)
+- Fail fast on data quality issues
+- Never silently swallow exceptions
+
+## Git Conventions
+
+- Conventional commits: `type(scope): description`
+- Types: `feat`, `fix`, `data`, `model`, `pipeline`, `docs`, `test`
+- Branch naming: `feature/description`, `experiment/description`
+- PR titles under 72 characters
+- Include metrics in PR description for model changes
+
+## Dependencies
+
+- Pin exact versions in `requirements.txt`
+- Use `pyproject.toml` for package metadata
+- Separate dev dependencies from production
+- Document CUDA/GPU requirements explicitly
+

package/dist/presets/data-ai/docs/project-roadmap.md

@@ -0,0 +1,79 @@
+# Project Roadmap
+
+## Current Phase: [Phase Name]
+
+**Status**: In Progress
+**Target**: [Date]
+
+## Phase 1: Data Foundation
+
+**Status**: Not Started
+**Priority**: High
+
+- [ ] Data source identification and access
+- [ ] Raw data ingestion pipeline
+- [ ] Data quality validation framework
+- [ ] Exploratory data analysis
+- [ ] Feature engineering baseline
+
+**Success Criteria**: Clean dataset available with documented quality metrics.
+
+## Phase 2: Model Development
+
+**Status**: Not Started
+**Priority**: High
+
+- [ ] Baseline model implementation
+- [ ] Experiment tracking setup (MLflow/W&B)
+- [ ] Feature engineering iteration
+- [ ] Hyperparameter tuning
+- [ ] Model evaluation and comparison
+
+**Success Criteria**: Model meets target metrics on validation set.
+
+## Phase 3: Pipeline Automation
+
+**Status**: Not Started
+**Priority**: Medium
+
+- [ ] Training pipeline automation
+- [ ] Data refresh scheduling
+- [ ] Feature computation pipeline
+- [ ] Model retraining triggers
+- [ ] CI/CD for ML code
+
+**Success Criteria**: End-to-end pipeline runs without manual intervention.
+
+## Phase 4: Deployment and Serving
+
+**Status**: Not Started
+**Priority**: Medium
+
+- [ ] Model serving endpoint
+- [ ] Input validation and preprocessing
+- [ ] A/B testing infrastructure
+- [ ] Monitoring and alerting
+- [ ] Rollback mechanisms
+
+**Success Criteria**: Model serving in production with monitoring.
+
+## Phase 5: Monitoring and Iteration
+
+**Status**: Not Started
+**Priority**: High
+
+- [ ] Prediction monitoring (drift detection)
+- [ ] Performance dashboards
+- [ ] Automated retraining on drift
+- [ ] Feedback loop integration
+- [ ] Documentation and knowledge transfer
+
+**Success Criteria**: Self-maintaining system with drift detection and alerts.
+
+---
+
+## Changelog
+
+### [Unreleased]
+- Initial project setup
+

package/dist/presets/data-ai/docs/system-architecture.md

@@ -0,0 +1,97 @@
+# System Architecture
+
+## Overview
+
+This document describes the data/ML system architecture including data pipelines, model training infrastructure, and serving components.
+
+## Architecture Diagram
+
+```
+Data Sources
+  |
+  v
+Ingestion Layer
+  |
+  +-- Raw Storage (S3/GCS/local)
+  |
+  v
+Processing Pipeline
+  |
+  +-- Data Validation (Great Expectations)
+  +-- Feature Engineering (pandas/Spark)
+  +-- Feature Store (Feast/custom)
+  |
+  v
+Training Pipeline
+  |
+  +-- Experiment Tracking (MLflow/W&B)
+  +-- Model Training (PyTorch/TF/sklearn)
+  +-- Hyperparameter Tuning (Optuna)
+  +-- Model Registry
+  |
+  v
+Serving Layer
+  |
+  +-- Model Serving (BentoML/FastAPI)
+  +-- Monitoring (Evidently)
+  +-- A/B Testing
+```
+
+## Key Architectural Decisions
+
+### Data Pipeline
+- Batch processing for training data (daily/hourly)
+- Schema validation at every pipeline boundary
+- Idempotent transformations (safe to re-run)
+- Data versioning with DVC or similar
+
+### Model Training
+- Configuration-driven training (YAML configs)
+- Reproducible experiments (seeds, pinned deps)
+- Automated hyperparameter search
+- Model versioning in registry
+
+### Serving
+- Containerized model serving
+- Health checks and graceful degradation
+- Input validation before inference
+- Prediction logging for monitoring
+
+## Directory Structure
+
+```
+project-root/
+  src/                 Source code (importable package)
+  notebooks/           Exploration and analysis
+  configs/             Training and pipeline configs
+  data/                Data storage (gitignored)
+  models/              Model artifacts (gitignored)
+  tests/               Test suite
+  reports/             Generated reports
+  pipelines/           Pipeline definitions (Airflow/Prefect)
+```
+
+## Data Flow
+
+- Raw data ingested to `data/raw/` (immutable)
+- Processing outputs to `data/processed/`
+- Features computed to `data/features/`
+- Models saved to `models/` with metadata
+- Predictions logged for monitoring
+
+## Security
+
+- Credentials in environment variables only
+- Data access controlled by IAM roles
+- Model endpoints require authentication
+- PII handling follows data governance policy
+- Audit logging for data access
+
+## Performance
+
+- Vectorized operations over row-by-row processing
+- GPU utilization monitoring during training
+- Batch inference for throughput
+- Caching for repeated computations
+- Memory-efficient data loading (chunked reads)
+

package/dist/presets/data-ai/hooks/.env.example

@@ -0,0 +1,9 @@
+# Hook environment variables
+# Copy this file to .env and fill in your values.
+
+# Discord webhook URL for notifications
+DISCORD_WEBHOOK_URL=<your-discord-webhook-url>
+
+# Telegram bot token and chat ID for notifications
+TELEGRAM_BOT_TOKEN=<your-telegram-bot-token>
+TELEGRAM_CHAT_ID=<your-telegram-chat-id>

package/dist/presets/data-ai/hooks/README.md

@@ -0,0 +1,28 @@
+# Hooks
+
+Cross-platform hook scripts for Kiro IDE automation.
+
+## Available Hooks
+
+| Hook | Trigger | Description |
+|------|---------|-------------|
+| scout-block | PreToolUse | Blocks dangerous commands (rm -rf, drop database, etc.) |
+| modularization-hook | PostToolUse | Warns when files exceed 200 lines |
+| discord-notify | agentStop | Sends notification via Discord webhook |
+| telegram-notify | agentStop | Sends notification via Telegram bot |
+| pre-commit-lint | PreToolUse | Runs linter before commit |
+| git-status-tracker | PostToolUse | Logs git working tree status summary |
+
+## Platform Support
+
+Each hook has a primary `.js` (Node.js) version and platform-specific fallbacks:
+- `.js` - Cross-platform (requires Node.js)
+- `.sh` - Unix/macOS/Linux (bash)
+- `.ps1` - Windows (PowerShell)
+
+## Environment Variables
+
+Copy `hooks/.env.example` to `hooks/.env` and configure:
+- `DISCORD_WEBHOOK_URL` - Required for discord-notify
+- `TELEGRAM_BOT_TOKEN` - Required for telegram-notify
+- `TELEGRAM_CHAT_ID` - Required for telegram-notify

package/dist/presets/data-ai/hooks/discord-notify.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+// Sends a notification to Discord via webhook.
+// Requires DISCORD_WEBHOOK_URL in hooks/.env or environment.
+
+const https = require('https');
+
+const WEBHOOK_URL = process.env.DISCORD_WEBHOOK_URL || '';
+const message = process.argv.slice(2).join(' ') || 'Agent task completed.';
+
+if (!WEBHOOK_URL) {
+  process.stderr.write('[discord-notify] DISCORD_WEBHOOK_URL not set. Skipping.\n');
+  process.exit(0);
+}
+
+const url = new URL(WEBHOOK_URL);
+const payload = JSON.stringify({ content: message });
+
+const options = {
+  hostname: url.hostname,
+  path: url.pathname,
+  method: 'POST',
+  headers: { 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(payload) },
+};
+
+const req = https.request(options, (res) => {
+  process.exit(res.statusCode >= 200 && res.statusCode < 300 ? 0 : 1);
+});
+
+req.on('error', () => process.exit(1));
+req.write(payload);
+req.end();

package/dist/presets/data-ai/hooks/discord-notify.ps1

@@ -0,0 +1,19 @@
+# Sends a notification to Discord via webhook.
+# Requires DISCORD_WEBHOOK_URL in environment.
+
+$Message = if ($args.Count -gt 0) { $args -join ' ' } else { 'Agent task completed.' }
+
+$WebhookUrl = $env:DISCORD_WEBHOOK_URL
+
+if (-not $WebhookUrl) {
+    Write-Error "[discord-notify] DISCORD_WEBHOOK_URL not set. Skipping."
+    exit 0
+}
+
+$Body = @{ content = $Message } | ConvertTo-Json
+try {
+    Invoke-RestMethod -Uri $WebhookUrl -Method Post -Body $Body -ContentType 'application/json'
+    exit 0
+} catch {
+    exit 1
+}

package/dist/presets/data-ai/hooks/discord-notify.sh

@@ -0,0 +1,15 @@
+#!/usr/bin/env bash
+# Sends a notification to Discord via webhook.
+# Requires DISCORD_WEBHOOK_URL in environment.
+
+MESSAGE="${*:-Agent task completed.}"
+
+if [ -z "$DISCORD_WEBHOOK_URL" ]; then
+  echo "[discord-notify] DISCORD_WEBHOOK_URL not set. Skipping." >&2
+  exit 0
+fi
+
+curl -s -o /dev/null -w "%{http_code}" \
+  -H "Content-Type: application/json" \
+  -d "{\"content\": \"$MESSAGE\"}" \
+  "$DISCORD_WEBHOOK_URL" | grep -q "^2" && exit 0 || exit 1