kiro-kit 0.1.0

package/dist/presets/data-ai/skills/jupyter-notebooks/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: jupyter-notebooks
+description: Work effectively with Jupyter notebooks for data exploration and analysis. Use when creating notebooks, converting formats, or establishing notebook best practices.
+---
+
+# Jupyter Notebooks
+
+Activate this skill when working with Jupyter notebooks in data science workflows.
+
+## When to Use
+
+- Creating exploratory data analysis notebooks
+- Converting notebooks to scripts or reports
+- Establishing notebook conventions for teams
+- Debugging notebook execution issues
+- Setting up JupyterLab environments
+
+## Best Practices
+
+- Keep notebooks focused on one analysis question
+- Use markdown cells for documentation between code
+- Clear outputs before committing to version control
+- Extract reusable code into `.py` modules
+- Number sections for narrative flow
+
+## Structure
+
+```
+notebooks/
+  01-data-exploration.ipynb
+  02-feature-engineering.ipynb
+  03-model-training.ipynb
+  04-evaluation.ipynb
+  utils/
+    __init__.py
+    plotting.py
+    preprocessing.py
+```
+
+## Tools
+
+```bash
+# Convert to script
+jupyter nbconvert --to script notebook.ipynb
+
+# Convert to HTML report
+jupyter nbconvert --to html --no-input notebook.ipynb
+
+# Run notebook headless
+papermill input.ipynb output.ipynb -p param_name value
+```
+
+## Rules
+
+- Never store secrets in notebooks
+- Use parameterized notebooks for reproducibility
+- Pin library versions in notebook headers
+- Keep cell execution order linear (no jumping)
+- Use nbstripout to clean outputs before commits
+

package/dist/presets/data-ai/skills/mcp-builder/SKILL.md

@@ -0,0 +1,40 @@
+---
+name: mcp-builder
+description: Build MCP (Model Context Protocol) servers for data and ML tool integration. Use when creating custom tool servers for database access, model inference, or data processing.
+---
+
+# MCP Builder
+
+Activate this skill when building MCP servers for data/ML integrations.
+
+## When to Use
+
+- Creating database query tools for agents
+- Building model inference endpoints as MCP tools
+- Wrapping data processing functions as tools
+- Integrating external APIs (cloud ML services)
+- Building custom data retrieval tools
+
+## Structure
+
+```python
+from mcp.server import Server
+from mcp.types import Tool
+
+server = Server("data-tools")
+
+@server.tool()
+async def query_dataset(query: str, dataset: str) -> str:
+    """Execute a query against a dataset."""
+    # Implementation
+    return results
+```
+
+## Rules
+
+- Keep tools focused on single responsibilities
+- Use typed parameters with clear descriptions
+- Handle errors gracefully with informative messages
+- Document expected inputs and outputs
+- Test tools independently before integration
+

package/dist/presets/data-ai/skills/mcp-management/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: mcp-management
+description: Manage MCP server configurations and tool discovery. Use when configuring data tool servers, discovering available capabilities, or troubleshooting MCP connections.
+---
+
+# MCP Management
+
+Activate this skill when managing MCP server integrations for data workflows.
+
+## When to Use
+
+- Configuring MCP servers in `.kiro/mcp.json`
+- Discovering available tools from connected servers
+- Troubleshooting MCP connection issues
+- Selecting appropriate tools for data tasks
+- Managing server lifecycle and resources
+
+## Configuration
+
+```json
+{
+  "mcpServers": {
+    "data-tools": {
+      "command": "python",
+      "args": ["-m", "data_tools.server"],
+      "env": {
+        "DATABASE_URL": "${DATABASE_URL}"
+      }
+    }
+  }
+}
+```
+
+## Rules
+
+- Verify server health before relying on tools
+- Use environment variables for credentials
+- Document available tools and their parameters
+- Handle server disconnections gracefully
+- Monitor tool execution times for performance
+

package/dist/presets/data-ai/skills/ml-ops/SKILL.md

@@ -0,0 +1,45 @@
+---
+name: ml-ops
+description: Deploy, monitor, and manage ML models in production. Use when setting up model serving, experiment tracking, or ML infrastructure.
+---
+
+# MLOps
+
+Activate this skill when deploying models or managing ML infrastructure.
+
+## When to Use
+
+- Deploying models to production endpoints
+- Setting up experiment tracking (MLflow, W&B)
+- Building model registries and versioning
+- Implementing A/B testing for models
+- Monitoring model drift and performance
+
+## Core Tools
+
+- **MLflow**: Experiment tracking, model registry
+- **Weights & Biases**: Experiment visualization
+- **BentoML/Ray Serve**: Model serving
+- **DVC**: Data and model versioning
+- **Evidently AI**: Model monitoring
+
+## Patterns
+
+```python
+import mlflow
+
+mlflow.set_experiment("classification_v2")
+with mlflow.start_run():
+    mlflow.log_params({"lr": 0.001, "epochs": 50})
+    mlflow.log_metrics({"accuracy": 0.94, "f1": 0.91})
+    mlflow.sklearn.log_model(model, "model")
+```
+
+## Rules
+
+- Version everything: code, data, models, configs
+- Automate training pipelines (no manual steps)
+- Monitor prediction distributions for drift
+- Implement rollback mechanisms for model updates
+- Log all experiments, even failed ones
+

package/dist/presets/data-ai/skills/nlp-text-processing/SKILL.md

@@ -0,0 +1,48 @@
+---
+name: nlp-text-processing
+description: Process and analyze text data with NLP techniques. Use when building text classification, NER, sentiment analysis, or text preprocessing pipelines.
+---
+
+# NLP Text Processing
+
+Activate this skill when working with text data and natural language processing.
+
+## When to Use
+
+- Text preprocessing and cleaning
+- Building text classification models
+- Named entity recognition (NER)
+- Sentiment analysis pipelines
+- Text embedding and similarity search
+- Working with Hugging Face transformers
+
+## Libraries
+
+- **spaCy**: Production NLP pipelines
+- **Hugging Face Transformers**: Pre-trained models
+- **NLTK**: Classic NLP tools
+- **sentence-transformers**: Text embeddings
+
+## Patterns
+
+```python
+from transformers import pipeline
+
+# Quick inference
+classifier = pipeline("text-classification", model="distilbert-base-uncased")
+result = classifier("This product is amazing!")
+
+# Custom fine-tuning
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
+model = AutoModelForSequenceClassification.from_pretrained("bert-base-uncased")
+```
+
+## Rules
+
+- Preprocess text consistently (lowercase, tokenize)
+- Handle multilingual text explicitly
+- Use pre-trained models before training from scratch
+- Validate with human evaluation, not just metrics
+- Consider computational cost of large language models
+

package/dist/presets/data-ai/skills/pandas-analysis/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: pandas-analysis
+description: Data manipulation and analysis with pandas. Use when cleaning data, performing aggregations, merging datasets, or building analysis pipelines.
+---
+
+# Pandas Analysis
+
+Activate this skill when working with tabular data using pandas.
+
+## When to Use
+
+- Cleaning and preprocessing datasets
+- Performing groupby aggregations
+- Merging and joining multiple DataFrames
+- Time series manipulation
+- Exploratory data analysis
+
+## Patterns
+
+```python
+import pandas as pd
+
+# Method chaining for clean pipelines
+result = (
+    df.pipe(clean_column_names)
+    .query("revenue > 0")
+    .assign(margin=lambda x: x.revenue - x.cost)
+    .groupby("category")
+    .agg(total_margin=("margin", "sum"), count=("margin", "size"))
+    .sort_values("total_margin", ascending=False)
+)
+```
+
+## Performance Tips
+
+- Use `category` dtype for low-cardinality strings
+- Prefer vectorized operations over `apply()`
+- Use `read_csv(usecols=...)` to load only needed columns
+- Consider `pyarrow` backend for large datasets
+- Use `query()` over boolean indexing for readability
+
+## Rules
+
+- Always inspect data shape and dtypes first
+- Handle missing values explicitly (never ignore NaN)
+- Validate assumptions about uniqueness and cardinality
+- Use `.copy()` to avoid SettingWithCopyWarning
+- Document data transformations with comments
+

package/dist/presets/data-ai/skills/planning/SKILL.md

@@ -0,0 +1,44 @@
+---
+name: planning
+description: Plan technical solutions for data science and ML projects. Use when designing experiments, architecting pipelines, or scoping ML features.
+---
+
+# Planning
+
+Activate this skill when planning data/ML technical solutions.
+
+## When to Use
+
+- Designing ML experiment roadmaps
+- Architecting data pipeline systems
+- Scoping new data science features
+- Planning model migration strategies
+- Estimating compute and data requirements
+
+## Process
+
+1. Define the problem and success metrics
+2. Identify constraints (data, compute, time, team)
+3. Research existing solutions and baselines
+4. Design approach with clear milestones
+5. Identify risks and mitigation strategies
+6. Create actionable task breakdown
+
+## Output Format
+
+Plans should include:
+- Problem statement (1-2 sentences)
+- Success criteria (measurable)
+- Approach overview
+- Task breakdown with estimates
+- Risks and mitigations
+- Resource requirements
+
+## Rules
+
+- Start with the simplest viable approach
+- Include data requirements and availability check
+- Account for experiment iteration time
+- Plan for failure modes and fallbacks
+- Do NOT implement -- only plan and report
+

package/dist/presets/data-ai/skills/problem-solving/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: problem-solving
+description: Apply systematic problem-solving techniques for data science and ML challenges. Use when stuck on complexity, innovation blocks, or recurring patterns.
+---
+
+# Problem Solving
+
+Activate this skill when facing complex data/ML challenges that need structured approaches.
+
+## When to Use
+
+- Complexity spirals in data pipelines
+- Innovation blocks in model design
+- Recurring patterns in failed experiments
+- Scale uncertainty in data systems
+- Choosing between competing approaches
+
+## Techniques
+
+### Simplification Cascade
+Strip the problem to its simplest form, solve that, then add complexity back incrementally.
+
+### Inversion Exercise
+Instead of "how to improve accuracy", ask "what would make accuracy worse?" and avoid those things.
+
+### Ablation Study
+Remove components one at a time to identify what actually contributes to the result.
+
+### Divide and Conquer
+Split the problem at natural boundaries (data vs model vs infrastructure).
+
+### Baseline First
+Always establish a simple baseline before attempting complex solutions.
+
+## Rules
+
+- Define success criteria before starting
+- Time-box exploration (2 hours max per approach)
+- Document what you tried and why it failed
+- Ask for help after 3 failed attempts
+- Simple solutions that work beat complex ones that might
+

package/dist/presets/data-ai/skills/pytorch-training/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: pytorch-training
+description: Train and optimize deep learning models with PyTorch. Use when building neural networks, implementing training loops, or optimizing model performance.
+---
+
+# PyTorch Training
+
+Activate this skill when training deep learning models with PyTorch.
+
+## When to Use
+
+- Implementing custom neural network architectures
+- Writing training and evaluation loops
+- Optimizing model performance (learning rate, batch size)
+- Implementing data loading and augmentation
+- Debugging gradient and convergence issues
+
+## Patterns
+
+```python
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader
+
+model = MyModel().to(device)
+optimizer = torch.optim.AdamW(model.parameters(), lr=3e-4)
+scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
+
+for epoch in range(epochs):
+    model.train()
+    for batch in train_loader:
+        optimizer.zero_grad()
+        loss = model(batch)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
+        optimizer.step()
+    scheduler.step()
+```
+
+## Best Practices
+
+- Use `torch.no_grad()` during evaluation
+- Implement gradient clipping for stability
+- Use mixed precision (`torch.cuda.amp`) for speed
+- Save checkpoints periodically
+- Profile with `torch.profiler` before optimizing
+
+## Rules
+
+- Always set random seeds for reproducibility
+- Move data and model to same device explicitly
+- Use DataLoader with `num_workers > 0` for I/O
+- Validate on held-out data every epoch
+- Log metrics to experiment tracker (W&B, MLflow)
+

package/dist/presets/data-ai/skills/repomix/SKILL.md

@@ -0,0 +1,40 @@
+---
+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 ML 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/**/*.py"
+
+# 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/data-ai/skills/research/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: research
+description: Research and analyze technical solutions, ML libraries, and data science best practices. Use when evaluating models, finding documentation, or investigating unfamiliar algorithms.
+---
+
+# Research
+
+Activate this skill when researching ML techniques, evaluating data tools, or finding best practices.
+
+## When to Use
+
+- Evaluating competing ML frameworks or libraries
+- Finding official documentation for data tools
+- Investigating algorithm implementations and trade-offs
+- Comparing model architectures for a use case
+- Checking dataset licenses and availability
+
+## Process
+
+1. Define the research question clearly
+2. Search authoritative sources (papers, official docs first)
+3. Cross-reference multiple sources for accuracy
+4. Evaluate applicability to the current project
+5. Summarize findings with confidence levels
+6. List unresolved questions
+
+## Rules
+
+- Prioritize official documentation and peer-reviewed papers
+- Note version numbers and compatibility (Python, CUDA)
+- Distinguish proven methods from experimental ones
+- Flag computational requirements and hardware needs
+- Be honest about confidence levels
+- Do NOT implement -- only research and report
+

package/dist/presets/data-ai/skills/scikit-learn/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: scikit-learn
+description: Classical machine learning with scikit-learn. Use when building classification, regression, clustering models, or implementing feature engineering pipelines.
+---
+
+# Scikit-learn
+
+Activate this skill when working with classical ML algorithms.
+
+## When to Use
+
+- Building classification or regression models
+- Feature engineering and selection
+- Implementing ML pipelines with preprocessing
+- Cross-validation and hyperparameter tuning
+- Clustering and dimensionality reduction
+
+## Patterns
+
+```python
+from sklearn.pipeline import Pipeline
+from sklearn.compose import ColumnTransformer
+from sklearn.preprocessing import StandardScaler, OneHotEncoder
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.model_selection import cross_val_score
+
+preprocessor = ColumnTransformer([
+    ("num", StandardScaler(), numeric_features),
+    ("cat", OneHotEncoder(handle_unknown="ignore"), categorical_features),
+])
+
+pipeline = Pipeline([
+    ("preprocessor", preprocessor),
+    ("classifier", GradientBoostingClassifier(n_estimators=200)),
+])
+
+scores = cross_val_score(pipeline, X, y, cv=5, scoring="f1_macro")
+```
+
+## Rules
+
+- Always split data before any preprocessing
+- Use pipelines to prevent data leakage
+- Cross-validate before reporting metrics
+- Start simple (LogisticRegression) before complex models
+- Document feature engineering decisions
+

package/dist/presets/data-ai/skills/sequential-thinking/SKILL.md

@@ -0,0 +1,34 @@
+---
+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 data pipeline decomposition
+- Multi-step ML experiment design
+- Debugging model performance issues
+- Architecture decisions with many trade-offs
+- Hypothesis-driven data investigation
+
+## 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/data-ai/skills/skill-creator/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: skill-creator
+description: Guide for creating effective agent skills. Use when building new skills to extend agent capabilities with specialized knowledge.
+---
+
+# Skill Creator
+
+Activate this skill when creating new skills for the data-ai agent ecosystem.
+
+## When to Use
+
+- Creating a new domain-specific skill
+- Updating an existing skill with new capabilities
+- Structuring skill knowledge for optimal retrieval
+- Designing skill activation triggers
+
+## Skill Structure
+
+```
+skills/[skill-name]/
+  SKILL.md           Required: front-matter + instructions
+  references/        Optional: additional documentation
+  scripts/           Optional: executable helper scripts
+  assets/            Optional: static files, templates
+```
+
+## SKILL.md Template
+
+```markdown
+---
+name: skill-name
+description: When to activate and what it provides.
+---
+
+# Skill Name
+
+## When to Use
+- Trigger condition 1
+- Trigger condition 2
+
+## Instructions
+[Domain knowledge and procedures]
+
+## Rules
+- Constraint 1
+- Constraint 2
+```
+
+## Rules
+
+- Keep SKILL.md under 200 lines
+- Description must clearly state activation triggers
+- Use progressive disclosure (details in references/)
+- Include practical examples over abstract theory
+- Test skill activation with sample prompts
+

package/dist/presets/data-ai/skills/template-skill/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: template-skill
+description: Template for creating new data/ML skills. Copy this folder and customize for your domain.
+---
+
+# Template Skill
+
+This is a template. Copy this folder and customize for your specific skill.
+
+## When to Use
+
+- [Describe activation triggers]
+- [When should the agent use this skill?]
+
+## Instructions
+
+[Add domain-specific knowledge, procedures, and patterns here]
+
+## Rules
+
+- [Add constraints and guidelines]
+- [What should the agent avoid?]
+

package/dist/presets/data-ai/skills/template-skill/assets/.gitkeep

@@ -0,0 +1 @@
+

package/dist/presets/data-ai/skills/template-skill/references/.gitkeep

@@ -0,0 +1 @@
+

package/dist/presets/data-ai/skills/template-skill/scripts/.gitkeep

@@ -0,0 +1 @@
+