kiro-kit 0.1.0

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

@@ -0,0 +1,41 @@
+---
+name: ai-multimodal
+description: Process and generate multimedia content using Google Gemini API. Use when analyzing images, processing documents, transcribing audio, or generating visual content for data science workflows.
+---
+
+# AI Multimodal
+
+Activate this skill when working with images, documents, audio, or multimedia content in data/AI projects.
+
+## When to Use
+
+- Analyzing charts, plots, and visualizations
+- Processing PDF research papers for extraction
+- Generating diagrams from text descriptions
+- Extracting tables from scanned documents
+- Transcribing audio recordings of meetings/interviews
+
+## Capabilities
+
+- Image analysis: chart interpretation, diagram understanding
+- Document processing: PDF tables, research papers, forms
+- Audio processing: transcription with timestamps
+- Video analysis: presentation extraction, lecture notes
+- Image generation: diagrams, flowcharts, architecture visuals
+
+## Data Science Applications
+
+- Extract data tables from PDF reports
+- Analyze matplotlib/seaborn plot outputs
+- Process handwritten notes and whiteboard photos
+- Generate architecture diagrams for ML pipelines
+- Transcribe data review meetings
+
+## Rules
+
+- Always verify extracted numerical data against source
+- Use appropriate model for task complexity
+- Handle large files with proper chunking
+- Validate OCR results for data accuracy
+- Respect content licensing and attribution
+

package/dist/presets/data-ai/skills/code-review/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: code-review
+description: Review data science and ML code for correctness, performance, and best practices. Use when receiving feedback, completing features, or before merging.
+---
+
+# Code Review
+
+Activate this skill when reviewing or receiving reviews on data/ML code.
+
+## When to Use
+
+- Reviewing data pipeline implementations
+- Checking ML training code for correctness
+- Validating data preprocessing logic
+- Ensuring reproducibility of experiments
+- Reviewing notebook-to-production conversions
+
+## Checklist
+
+### Data Quality
+- Input validation and schema checks
+- Missing value handling documented
+- Data leakage prevention (train/test separation)
+
+### ML Correctness
+- Random seeds set for reproducibility
+- Metrics computed on correct splits
+- Hyperparameters documented and justified
+- Baseline comparison included
+
+### Code Quality
+- Functions are testable and focused
+- Magic numbers replaced with named constants
+- Error handling for data edge cases
+- Type hints on public functions
+
+### Performance
+- Vectorized operations over loops
+- Appropriate data types (category, float32)
+- Memory-efficient processing for large datasets
+
+## Rules
+
+- Prioritize correctness over style
+- Flag potential data leakage immediately
+- Verify metrics are computed correctly
+- Check for hardcoded paths or credentials
+- Ensure experiments are reproducible
+

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

@@ -0,0 +1,47 @@
+---
+name: data-engineering
+description: Design and implement data pipelines, ETL processes, and data infrastructure. Use when building data ingestion, transformation, or storage systems.
+---
+
+# Data Engineering
+
+Activate this skill when designing data pipelines or working with data infrastructure.
+
+## When to Use
+
+- Building ETL/ELT pipelines
+- Designing data warehouse schemas
+- Implementing streaming data processing
+- Optimizing data storage and retrieval
+- Setting up data quality checks
+
+## Core Tools
+
+- **Apache Airflow**: Workflow orchestration
+- **dbt**: SQL-based transformations
+- **Apache Spark/PySpark**: Distributed processing
+- **DVC**: Data version control
+- **Great Expectations**: Data validation
+
+## Patterns
+
+```python
+# Airflow DAG pattern
+from airflow import DAG
+from airflow.operators.python import PythonOperator
+
+with DAG("etl_pipeline", schedule="@daily") as dag:
+    extract = PythonOperator(task_id="extract", python_callable=extract_fn)
+    transform = PythonOperator(task_id="transform", python_callable=transform_fn)
+    load = PythonOperator(task_id="load", python_callable=load_fn)
+    extract >> transform >> load
+```
+
+## Rules
+
+- Idempotent operations (safe to re-run)
+- Schema validation at pipeline boundaries
+- Incremental processing over full reloads when possible
+- Monitor data freshness and quality metrics
+- Version control data schemas alongside code
+

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

@@ -0,0 +1,46 @@
+---
+name: data-visualization
+description: Create effective data visualizations with matplotlib, seaborn, and plotly. Use when building charts, dashboards, or communicating data insights visually.
+---
+
+# Data Visualization
+
+Activate this skill when creating charts, plots, or visual data presentations.
+
+## When to Use
+
+- Creating exploratory data analysis plots
+- Building publication-quality figures
+- Designing interactive dashboards
+- Communicating model results visually
+- Comparing distributions and relationships
+
+## Libraries
+
+- **matplotlib**: Foundation, full control
+- **seaborn**: Statistical visualization, clean defaults
+- **plotly**: Interactive charts, dashboards
+- **altair**: Declarative, grammar of graphics
+
+## Patterns
+
+```python
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+fig, axes = plt.subplots(1, 2, figsize=(12, 5))
+sns.histplot(data=df, x="value", hue="category", ax=axes[0])
+sns.scatterplot(data=df, x="feature_1", y="target", ax=axes[1])
+plt.tight_layout()
+plt.savefig("analysis.png", dpi=150, bbox_inches="tight")
+```
+
+## Rules
+
+- Always label axes and add titles
+- Use colorblind-friendly palettes
+- Choose chart type based on data relationship
+- Keep visualizations simple and focused
+- Save figures at appropriate resolution (150+ DPI)
+- Include units in axis labels
+

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

@@ -0,0 +1,42 @@
+---
+name: debugging
+description: Systematic debugging framework for data and ML code. Use when encountering bugs, test failures, unexpected model behavior, or data quality issues.
+---
+
+# Debugging
+
+Activate this skill when investigating bugs, failures, or unexpected behavior.
+
+## When to Use
+
+- Model producing unexpected predictions
+- Data pipeline failures or data quality issues
+- Test failures in ML code
+- Performance degradation in production
+- Memory or compute resource issues
+
+## Process
+
+1. **Reproduce**: Isolate the minimal case that triggers the issue
+2. **Observe**: Gather evidence (logs, metrics, data samples)
+3. **Hypothesize**: Form testable theories about root cause
+4. **Test**: Validate or eliminate each hypothesis
+5. **Fix**: Apply targeted fix based on confirmed root cause
+6. **Verify**: Confirm fix resolves issue without side effects
+
+## Common ML Debugging
+
+- **NaN loss**: Check for division by zero, log(0), extreme values
+- **No convergence**: Reduce learning rate, check data normalization
+- **Overfitting**: Add regularization, reduce model capacity
+- **Data leakage**: Verify train/test split happens before preprocessing
+- **Shape mismatch**: Print tensor shapes at each layer
+
+## Rules
+
+- Never fix without understanding root cause
+- Add assertions/tests to prevent regression
+- Check data first (garbage in, garbage out)
+- Use deterministic seeds when debugging randomness
+- Document the fix and why it works
+

package/dist/presets/data-ai/skills/docs-seeker/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: docs-seeker
+description: Search and retrieve technical documentation for data science libraries and ML frameworks. Use when you need to find API references, usage examples, or migration guides.
+---
+
+# Docs Seeker
+
+Activate this skill when searching for documentation on data/ML libraries.
+
+## When to Use
+
+- Finding API references for pandas, scikit-learn, PyTorch
+- Looking up function signatures and parameters
+- Finding migration guides between library versions
+- Searching for usage examples and tutorials
+- Checking compatibility between library versions
+
+## Process
+
+1. Identify the library and version
+2. Search official documentation first
+3. Check changelog for version-specific changes
+4. Look for community examples if official docs are sparse
+5. Verify information is current (check dates)
+
+## Sources Priority
+
+1. Official library documentation
+2. GitHub repository README and examples
+3. Published papers (for algorithms)
+4. Stack Overflow (verified answers only)
+5. Blog posts (recent, from known authors)
+
+## Rules
+
+- Always note the library version
+- Prefer official docs over third-party tutorials
+- Verify code examples actually run
+- Check deprecation warnings
+- Report when documentation is unclear or missing
+

package/dist/presets/data-ai/skills/document-skills/docx/SKILL.md

@@ -0,0 +1,49 @@
+---
+name: document-skills-docx
+description: Process and generate Word documents (DOCX) programmatically. Use when creating reports, extracting text from documents, or automating document generation in data pipelines.
+---
+
+# Document Skills - DOCX
+
+Activate this skill when working with Microsoft Word documents in Python.
+
+## When to Use
+
+- Generating automated reports from data analysis
+- Extracting text and tables from Word documents
+- Creating templated documents with dynamic content
+- Converting analysis results to formatted reports
+- Batch processing document collections
+
+## Libraries
+
+- **python-docx**: Create and modify DOCX files
+- **docx2txt**: Simple text extraction
+- **mammoth**: Convert DOCX to HTML/Markdown
+
+## Usage
+
+```python
+from docx import Document
+
+# Create report
+doc = Document()
+doc.add_heading("Analysis Report", level=0)
+doc.add_paragraph(f"Generated: {datetime.now()}")
+doc.add_table(rows=len(data)+1, cols=len(columns))
+doc.save("report.docx")
+
+# Extract content
+doc = Document("input.docx")
+for para in doc.paragraphs:
+    print(para.text)
+```
+
+## Rules
+
+- Use templates for consistent formatting
+- Handle encoding issues with non-ASCII text
+- Validate document structure before processing
+- Close file handles properly in pipelines
+- Test with various DOCX versions
+

package/dist/presets/data-ai/skills/document-skills/pdf/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: document-skills-pdf
+description: Extract and process PDF documents for data pipelines. Use when parsing research papers, extracting tables from reports, or converting PDFs to structured data.
+---
+
+# Document Skills - PDF
+
+Activate this skill when working with PDF documents in data/AI workflows.
+
+## When to Use
+
+- Extracting tables from financial reports
+- Parsing research papers for literature review
+- Converting scanned PDFs to text (OCR)
+- Extracting metadata from document collections
+- Building document processing pipelines
+
+## Libraries
+
+- **pypdf**: Read/write PDF, extract text and metadata
+- **pdfplumber**: Table extraction with spatial awareness
+- **PyMuPDF (fitz)**: Fast rendering and text extraction
+- **camelot-py**: Table extraction from PDFs
+- **pytesseract**: OCR for scanned documents
+
+## Usage
+
+```python
+import pdfplumber
+
+with pdfplumber.open("report.pdf") as pdf:
+    for page in pdf.pages:
+        tables = page.extract_tables()
+        text = page.extract_text()
+
+# OCR for scanned documents
+import pytesseract
+from pdf2image import convert_from_path
+
+images = convert_from_path("scanned.pdf")
+text = pytesseract.image_to_string(images[0])
+```
+
+## Rules
+
+- Check if PDF is text-based or scanned before processing
+- Use pdfplumber for table extraction over regex parsing
+- Handle multi-column layouts carefully
+- Validate extracted numbers against visual inspection
+- Process large PDFs page-by-page to manage memory
+

package/dist/presets/data-ai/skills/document-skills/pptx/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: document-skills-pptx
+description: Process and generate PowerPoint presentations programmatically. Use when creating data presentations, extracting content from slides, or automating report generation.
+---
+
+# Document Skills - PPTX
+
+Activate this skill when working with PowerPoint presentations in Python.
+
+## When to Use
+
+- Generating presentations from analysis results
+- Extracting text and data from existing presentations
+- Creating templated slide decks with charts
+- Automating weekly/monthly report presentations
+- Converting data visualizations to slide format
+
+## Libraries
+
+- **python-pptx**: Create and modify PPTX files
+- **pptx2md**: Convert presentations to Markdown
+
+## Usage
+
+```python
+from pptx import Presentation
+from pptx.util import Inches, Pt
+
+prs = Presentation()
+
+# Title slide
+slide = prs.slides.add_slide(prs.slide_layouts[0])
+slide.shapes.title.text = "Q4 Analysis Results"
+slide.placeholders[1].text = "Data Science Team"
+
+# Chart slide
+slide = prs.slides.add_slide(prs.slide_layouts[5])
+slide.shapes.title.text = "Revenue Trends"
+slide.shapes.add_picture("chart.png", Inches(1), Inches(2))
+
+prs.save("report.pptx")
+```
+
+## Rules
+
+- Use slide layouts for consistent formatting
+- Keep chart images at appropriate resolution (150+ DPI)
+- Limit text per slide for readability
+- Use master slides for branding consistency
+- Handle missing placeholders gracefully
+

package/dist/presets/data-ai/skills/document-skills/xlsx/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: document-skills-xlsx
+description: Process and generate Excel spreadsheets programmatically. Use when reading data from Excel files, creating formatted reports, or building data export pipelines.
+---
+
+# Document Skills - XLSX
+
+Activate this skill when working with Excel spreadsheets in data pipelines.
+
+## When to Use
+
+- Reading datasets from Excel files into DataFrames
+- Generating formatted Excel reports with charts
+- Processing multi-sheet workbooks
+- Creating pivot tables and summaries in Excel format
+- Automating data export to stakeholder-friendly formats
+
+## Libraries
+
+- **openpyxl**: Read/write XLSX with formatting
+- **pandas**: DataFrame to/from Excel (uses openpyxl backend)
+- **xlsxwriter**: Write-only with advanced formatting
+
+## Usage
+
+```python
+import pandas as pd
+from openpyxl import Workbook
+from openpyxl.chart import BarChart, Reference
+
+# Read with pandas
+df = pd.read_excel("data.xlsx", sheet_name="Sales")
+
+# Write formatted report
+with pd.ExcelWriter("report.xlsx", engine="openpyxl") as writer:
+    df.to_excel(writer, sheet_name="Summary", index=False)
+    details.to_excel(writer, sheet_name="Details", index=False)
+
+# Advanced formatting with openpyxl
+wb = Workbook()
+ws = wb.active
+ws.append(["Metric", "Value", "Change"])
+ws.column_dimensions["A"].width = 20
+wb.save("formatted.xlsx")
+```
+
+## Rules
+
+- Use pandas for simple read/write, openpyxl for formatting
+- Handle merged cells and multi-header sheets carefully
+- Validate data types after reading (dates, numbers)
+- Close file handles to avoid corruption
+- Test with both .xls and .xlsx formats when needed
+

package/dist/presets/data-ai/skills/experiment-tracking/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: experiment-tracking
+description: Track ML experiments systematically with MLflow, W&B, or similar tools. Use when running experiments, comparing model versions, or managing reproducibility.
+---
+
+# Experiment Tracking
+
+Activate this skill when managing ML experiments and reproducibility.
+
+## When to Use
+
+- Logging hyperparameters and metrics
+- Comparing experiment runs
+- Tracking model artifacts and versions
+- Reproducing previous results
+- Sharing experiment results with team
+
+## Tools
+
+- **MLflow**: Open-source, self-hosted
+- **Weights & Biases**: Cloud-hosted, rich UI
+- **DVC**: Git-based data/model versioning
+- **Neptune.ai**: Metadata management
+
+## Patterns
+
+```python
+import mlflow
+
+mlflow.set_experiment("text-classification")
+
+with mlflow.start_run(run_name="bert-base-lr3e5"):
+    mlflow.log_params({
+        "model": "bert-base-uncased",
+        "lr": 3e-5,
+        "epochs": 10,
+        "batch_size": 32,
+    })
+    # Training...
+    mlflow.log_metrics({"val_f1": 0.89, "val_loss": 0.34})
+    mlflow.log_artifact("confusion_matrix.png")
+    mlflow.transformers.log_model(model, "model")
+```
+
+## Rules
+
+- Log everything: params, metrics, artifacts, environment
+- Use meaningful run names and tags
+- Track data versions alongside model versions
+- Set random seeds and log them
+- Never delete experiment history
+

package/dist/presets/data-ai/skills/feature-store/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: feature-store
+description: Design and manage feature stores for ML systems. Use when building reusable feature pipelines, managing feature versioning, or serving features for inference.
+---
+
+# Feature Store
+
+Activate this skill when working with feature engineering at scale.
+
+## When to Use
+
+- Building reusable feature computation pipelines
+- Managing feature versioning and lineage
+- Serving features for online inference
+- Sharing features across ML models
+- Ensuring training-serving consistency
+
+## Tools
+
+- **Feast**: Open-source feature store
+- **Hopsworks**: Full-featured platform
+- **Custom**: pandas + SQL + caching
+
+## Patterns
+
+```python
+from feast import FeatureStore, Entity, FeatureView
+
+store = FeatureStore(repo_path="feature_repo/")
+
+# Define features
+user_features = FeatureView(
+    name="user_features",
+    entities=[user_entity],
+    schema=[
+        Field(name="total_purchases", dtype=Int64),
+        Field(name="avg_order_value", dtype=Float64),
+    ],
+    source=user_source,
+)
+
+# Retrieve for training
+training_df = store.get_historical_features(
+    entity_df=entity_df,
+    features=["user_features:total_purchases"],
+).to_df()
+```
+
+## Rules
+
+- Compute features once, use everywhere
+- Version features alongside model versions
+- Monitor feature distributions for drift
+- Document feature semantics and business logic
+- Test feature pipelines with known inputs
+

package/dist/presets/data-ai/skills/google-adk-python/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: google-adk-python
+description: Build AI agents with Google Agent Development Kit (ADK) for Python. Use when creating multi-agent systems, tool-using agents, or orchestrating LLM workflows with Google Cloud.
+---
+
+# Google ADK Python
+
+Activate this skill when building AI agents with Google's Agent Development Kit.
+
+## When to Use
+
+- Creating multi-agent orchestration systems
+- Building tool-using AI agents
+- Integrating with Google Cloud AI services
+- Designing agent communication protocols
+- Implementing RAG pipelines with ADK
+
+## Core Concepts
+
+- **Agent**: Autonomous unit with instructions, tools, and model
+- **Tool**: Function callable by the agent (Python functions, APIs)
+- **Session**: Conversation state management
+- **Runner**: Execution engine for agent invocations
+- **Orchestrator**: Multi-agent coordination patterns
+
+## Setup
+
+```python
+from google.adk import Agent, Tool, Runner
+
+agent = Agent(
+    name="data-analyst",
+    model="gemini-2.0-flash",
+    instructions="You analyze datasets and produce insights.",
+    tools=[query_database, generate_chart],
+)
+
+runner = Runner(agent=agent)
+response = runner.run("Analyze Q4 sales trends")
+```
+
+## Patterns
+
+- Sequential agent chains for multi-step analysis
+- Parallel agents for independent data processing
+- Supervisor pattern for quality control
+- Tool composition for complex workflows
+
+## Rules
+
+- Define clear agent boundaries and responsibilities
+- Use typed tool parameters with Pydantic models
+- Handle tool failures gracefully with retries
+- Keep agent instructions concise and focused
+- Test agents with deterministic inputs first
+