gkt-node 3.3.0

package/assets/.agent/skills/datadog-automation/SKILL.md

@@ -0,0 +1,235 @@
+---
+name: datadog-automation
+description: "Automate Datadog tasks via Rube MCP (Composio): query metrics, search logs, manage monitors/dashboards, create events and downtimes. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Datadog Automation via Rube MCP
+
+Automate Datadog monitoring and observability operations through Composio's Datadog toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Datadog connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `datadog`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+
+## Setup
+
+**Get Rube MCP**: Add `https://rube.app/mcp` as an MCP server in your client configuration. No API keys needed — just add the endpoint and it works.
+
+
+1. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
+2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `datadog`
+3. If connection is not ACTIVE, follow the returned auth link to complete Datadog authentication
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Query and Explore Metrics
+
+**When to use**: User wants to query metric data or list available metrics
+
+**Tool sequence**:
+1. `DATADOG_LIST_METRICS` - List available metric names [Optional]
+2. `DATADOG_QUERY_METRICS` - Query metric time series data [Required]
+
+**Key parameters**:
+- `query`: Datadog metric query string (e.g., `avg:system.cpu.user{host:web01}`)
+- `from`: Start timestamp (Unix epoch seconds)
+- `to`: End timestamp (Unix epoch seconds)
+- `q`: Search string for listing metrics
+
+**Pitfalls**:
+- Query syntax follows Datadog's metric query format: `aggregation:metric_name{tag_filters}`
+- `from` and `to` are Unix epoch timestamps in seconds, not milliseconds
+- Valid aggregations: `avg`, `sum`, `min`, `max`, `count`
+- Tag filters use curly braces: `{host:web01,env:prod}`
+- Time range should not exceed Datadog's retention limits for the metric type
+
+### 2. Search and Analyze Logs
+
+**When to use**: User wants to search log entries or list log indexes
+
+**Tool sequence**:
+1. `DATADOG_LIST_LOG_INDEXES` - List available log indexes [Optional]
+2. `DATADOG_SEARCH_LOGS` - Search logs with query and filters [Required]
+
+**Key parameters**:
+- `query`: Log search query using Datadog log query syntax
+- `from`: Start time (ISO 8601 or Unix timestamp)
+- `to`: End time (ISO 8601 or Unix timestamp)
+- `sort`: Sort order ('asc' or 'desc')
+- `limit`: Number of log entries to return
+
+**Pitfalls**:
+- Log queries use Datadog's log search syntax: `service:web status:error`
+- Search is limited to retained logs within the configured retention period
+- Large result sets require pagination; check for cursor/page tokens
+- Log indexes control routing and retention; filter by index if known
+
+### 3. Manage Monitors
+
+**When to use**: User wants to create, update, mute, or inspect monitors
+
+**Tool sequence**:
+1. `DATADOG_LIST_MONITORS` - List all monitors with filters [Required]
+2. `DATADOG_GET_MONITOR` - Get specific monitor details [Optional]
+3. `DATADOG_CREATE_MONITOR` - Create a new monitor [Optional]
+4. `DATADOG_UPDATE_MONITOR` - Update monitor configuration [Optional]
+5. `DATADOG_MUTE_MONITOR` - Silence a monitor temporarily [Optional]
+6. `DATADOG_UNMUTE_MONITOR` - Re-enable a muted monitor [Optional]
+
+**Key parameters**:
+- `monitor_id`: Numeric monitor ID
+- `name`: Monitor display name
+- `type`: Monitor type ('metric alert', 'service check', 'log alert', 'query alert', etc.)
+- `query`: Monitor query defining the alert condition
+- `message`: Notification message with @mentions
+- `tags`: Array of tag strings
+- `thresholds`: Alert threshold values (`critical`, `warning`, `ok`)
+
+**Pitfalls**:
+- Monitor `type` must match the query type; mismatches cause creation failures
+- `message` supports @mentions for notifications (e.g., `@slack-channel`, `@pagerduty`)
+- Thresholds vary by monitor type; metric monitors need `critical` at minimum
+- Muting a monitor suppresses notifications but the monitor still evaluates
+- Monitor IDs are numeric integers
+
+### 4. Manage Dashboards
+
+**When to use**: User wants to list, view, update, or delete dashboards
+
+**Tool sequence**:
+1. `DATADOG_LIST_DASHBOARDS` - List all dashboards [Required]
+2. `DATADOG_GET_DASHBOARD` - Get full dashboard definition [Optional]
+3. `DATADOG_UPDATE_DASHBOARD` - Update dashboard layout or widgets [Optional]
+4. `DATADOG_DELETE_DASHBOARD` - Remove a dashboard (irreversible) [Optional]
+
+**Key parameters**:
+- `dashboard_id`: Dashboard identifier string
+- `title`: Dashboard title
+- `layout_type`: 'ordered' (grid) or 'free' (freeform positioning)
+- `widgets`: Array of widget definition objects
+- `description`: Dashboard description
+
+**Pitfalls**:
+- Dashboard IDs are alphanumeric strings (e.g., 'abc-def-ghi'), not numeric
+- `layout_type` cannot be changed after creation; must recreate the dashboard
+- Widget definitions are complex nested objects; get existing dashboard first to understand structure
+- DELETE is permanent; there is no undo
+
+### 5. Create Events and Manage Downtimes
+
+**When to use**: User wants to post events or schedule maintenance downtimes
+
+**Tool sequence**:
+1. `DATADOG_LIST_EVENTS` - List existing events [Optional]
+2. `DATADOG_CREATE_EVENT` - Post a new event [Required]
+3. `DATADOG_CREATE_DOWNTIME` - Schedule a maintenance downtime [Optional]
+
+**Key parameters for events**:
+- `title`: Event title
+- `text`: Event body text (supports markdown)
+- `alert_type`: Event severity ('error', 'warning', 'info', 'success')
+- `tags`: Array of tag strings
+
+**Key parameters for downtimes**:
+- `scope`: Tag scope for the downtime (e.g., `host:web01`)
+- `start`: Start time (Unix epoch)
+- `end`: End time (Unix epoch; omit for indefinite)
+- `message`: Downtime description
+- `monitor_id`: Specific monitor to downtime (optional, omit for scope-based)
+
+**Pitfalls**:
+- Event `text` supports Datadog's markdown format including @mentions
+- Downtimes scope uses tag syntax: `host:web01`, `env:staging`
+- Omitting `end` creates an indefinite downtime; always set an end time for maintenance
+- Downtime `monitor_id` narrows to a single monitor; scope applies to all matching monitors
+
+### 6. Manage Hosts and Traces
+
+**When to use**: User wants to list infrastructure hosts or inspect distributed traces
+
+**Tool sequence**:
+1. `DATADOG_LIST_HOSTS` - List all reporting hosts [Required]
+2. `DATADOG_GET_TRACE_BY_ID` - Get a specific distributed trace [Optional]
+
+**Key parameters**:
+- `filter`: Host search filter string
+- `sort_field`: Sort hosts by field (e.g., 'name', 'apps', 'cpu')
+- `sort_dir`: Sort direction ('asc' or 'desc')
+- `trace_id`: Distributed trace ID for trace lookup
+
+**Pitfalls**:
+- Host list includes all hosts reporting to Datadog within the retention window
+- Trace IDs are long numeric strings; ensure exact match
+- Hosts that stop reporting are retained for a configured period before removal
+
+## Common Patterns
+
+### Monitor Query Syntax
+
+**Metric alerts**:
+```
+avg(last_5m):avg:system.cpu.user{env:prod} > 90
+```
+
+**Log alerts**:
+```
+logs("service:web status:error").index("main").rollup("count").last("5m") > 10
+```
+
+### Tag Filtering
+
+- Tags use `key:value` format: `host:web01`, `env:prod`, `service:api`
+- Multiple tags: `{host:web01,env:prod}` (AND logic)
+- Wildcard: `host:web*`
+
+### Pagination
+
+- Use `page` and `page_size` or offset-based pagination depending on endpoint
+- Check response for total count to determine if more pages exist
+- Continue until all results are retrieved
+
+## Known Pitfalls
+
+**Timestamps**:
+- Most endpoints use Unix epoch seconds (not milliseconds)
+- Some endpoints accept ISO 8601; check tool schema
+- Time ranges should be reasonable (not years of data)
+
+**Query Syntax**:
+- Metric queries: `aggregation:metric{tags}`
+- Log queries: `field:value` pairs
+- Monitor queries vary by type; check Datadog documentation
+
+**Rate Limits**:
+- Datadog API has per-endpoint rate limits
+- Implement backoff on 429 responses
+- Batch operations where possible
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| Query metrics | DATADOG_QUERY_METRICS | query, from, to |
+| List metrics | DATADOG_LIST_METRICS | q |
+| Search logs | DATADOG_SEARCH_LOGS | query, from, to, limit |
+| List log indexes | DATADOG_LIST_LOG_INDEXES | (none) |
+| List monitors | DATADOG_LIST_MONITORS | tags |
+| Get monitor | DATADOG_GET_MONITOR | monitor_id |
+| Create monitor | DATADOG_CREATE_MONITOR | name, type, query, message |
+| Update monitor | DATADOG_UPDATE_MONITOR | monitor_id |
+| Mute monitor | DATADOG_MUTE_MONITOR | monitor_id |
+| Unmute monitor | DATADOG_UNMUTE_MONITOR | monitor_id |
+| List dashboards | DATADOG_LIST_DASHBOARDS | (none) |
+| Get dashboard | DATADOG_GET_DASHBOARD | dashboard_id |
+| Update dashboard | DATADOG_UPDATE_DASHBOARD | dashboard_id, title, widgets |
+| Delete dashboard | DATADOG_DELETE_DASHBOARD | dashboard_id |
+| List events | DATADOG_LIST_EVENTS | start, end |
+| Create event | DATADOG_CREATE_EVENT | title, text, alert_type |
+| Create downtime | DATADOG_CREATE_DOWNTIME | scope, start, end |
+| List hosts | DATADOG_LIST_HOSTS | filter, sort_field |
+| Get trace | DATADOG_GET_TRACE_BY_ID | trace_id |

package/assets/.agent/skills/db-designer/SKILL.md

@@ -0,0 +1,22 @@
+---
+name: db-designer
+description: Generates standard SQL or Prisma database schemas.
+---
+
+# Database Designer
+
+## Purpose
+Generates database schemas for common entities in SQL or Prisma format.
+
+## Usage
+
+### 1. Generate SQL
+```bash
+python .agent/skills/db-designer/scripts/sql_gen.py --models "User, Product" --format sql
+```
+
+### 2. Generate Prisma Schema
+Generate `schema.prisma` models for modern Node.js stacks (Next.js, NestJS).
+```bash
+python .agent/skills/db-designer/scripts/sql_gen.py --models "User, Product" --format prisma
+```

package/assets/.agent/skills/db-designer/data/schema_patterns.json

@@ -0,0 +1,156 @@
+{
+    "schema_patterns": {
+        "users_auth": {
+            "description": "User authentication with roles and sessions",
+            "tables": {
+                "users": {
+                    "id": "UUID PRIMARY KEY DEFAULT gen_random_uuid()",
+                    "email": "VARCHAR(255) UNIQUE NOT NULL",
+                    "password_hash": "VARCHAR(255) NOT NULL",
+                    "name": "VARCHAR(100)",
+                    "avatar_url": "TEXT",
+                    "role": "ENUM('user','admin','moderator') DEFAULT 'user'",
+                    "email_verified_at": "TIMESTAMP",
+                    "created_at": "TIMESTAMP DEFAULT NOW()",
+                    "updated_at": "TIMESTAMP DEFAULT NOW()"
+                },
+                "sessions": {
+                    "id": "UUID PRIMARY KEY",
+                    "user_id": "UUID REFERENCES users(id) ON DELETE CASCADE",
+                    "token_hash": "VARCHAR(255) UNIQUE NOT NULL",
+                    "ip_address": "INET",
+                    "user_agent": "TEXT",
+                    "expires_at": "TIMESTAMP NOT NULL",
+                    "created_at": "TIMESTAMP DEFAULT NOW()"
+                }
+            }
+        },
+        "multi_tenant_saas": {
+            "description": "Multi-tenant SaaS with organizations and memberships",
+            "tables": {
+                "organizations": {
+                    "id": "UUID PRIMARY KEY",
+                    "name": "VARCHAR(100) NOT NULL",
+                    "slug": "VARCHAR(100) UNIQUE NOT NULL",
+                    "plan": "ENUM('free','pro','enterprise') DEFAULT 'free'",
+                    "created_at": "TIMESTAMP DEFAULT NOW()"
+                },
+                "memberships": {
+                    "id": "UUID PRIMARY KEY",
+                    "user_id": "UUID REFERENCES users(id)",
+                    "organization_id": "UUID REFERENCES organizations(id)",
+                    "role": "ENUM('owner','admin','member','viewer')",
+                    "invited_at": "TIMESTAMP",
+                    "joined_at": "TIMESTAMP"
+                }
+            }
+        },
+        "e_commerce": {
+            "description": "E-commerce with products, orders, and payments",
+            "tables": {
+                "products": {
+                    "id": "UUID PRIMARY KEY",
+                    "name": "VARCHAR(200) NOT NULL",
+                    "slug": "VARCHAR(200) UNIQUE NOT NULL",
+                    "description": "TEXT",
+                    "price": "DECIMAL(10,2) NOT NULL",
+                    "compare_at_price": "DECIMAL(10,2)",
+                    "sku": "VARCHAR(50) UNIQUE",
+                    "stock": "INTEGER DEFAULT 0",
+                    "category_id": "UUID REFERENCES categories(id)",
+                    "status": "ENUM('draft','active','archived') DEFAULT 'draft'",
+                    "images": "JSONB DEFAULT '[]'"
+                },
+                "orders": {
+                    "id": "UUID PRIMARY KEY",
+                    "user_id": "UUID REFERENCES users(id)",
+                    "status": "ENUM('pending','paid','shipped','delivered','cancelled')",
+                    "subtotal": "DECIMAL(10,2)",
+                    "tax": "DECIMAL(10,2)",
+                    "shipping": "DECIMAL(10,2)",
+                    "total": "DECIMAL(10,2)",
+                    "shipping_address": "JSONB",
+                    "created_at": "TIMESTAMP DEFAULT NOW()"
+                },
+                "order_items": {
+                    "id": "UUID PRIMARY KEY",
+                    "order_id": "UUID REFERENCES orders(id) ON DELETE CASCADE",
+                    "product_id": "UUID REFERENCES products(id)",
+                    "quantity": "INTEGER NOT NULL",
+                    "unit_price": "DECIMAL(10,2) NOT NULL"
+                }
+            }
+        },
+        "content_management": {
+            "description": "CMS with posts, categories, tags, and comments",
+            "tables": {
+                "posts": {
+                    "id": "UUID PRIMARY KEY",
+                    "author_id": "UUID REFERENCES users(id)",
+                    "title": "VARCHAR(200) NOT NULL",
+                    "slug": "VARCHAR(200) UNIQUE NOT NULL",
+                    "content": "TEXT",
+                    "excerpt": "TEXT",
+                    "featured_image": "TEXT",
+                    "status": "ENUM('draft','published','archived') DEFAULT 'draft'",
+                    "published_at": "TIMESTAMP",
+                    "created_at": "TIMESTAMP DEFAULT NOW()"
+                },
+                "categories": {
+                    "id": "UUID PRIMARY KEY",
+                    "name": "VARCHAR(100) NOT NULL",
+                    "slug": "VARCHAR(100) UNIQUE NOT NULL",
+                    "parent_id": "UUID REFERENCES categories(id)"
+                },
+                "tags": {
+                    "id": "UUID PRIMARY KEY",
+                    "name": "VARCHAR(50) UNIQUE NOT NULL"
+                },
+                "post_tags": {
+                    "post_id": "UUID REFERENCES posts(id) ON DELETE CASCADE",
+                    "tag_id": "UUID REFERENCES tags(id) ON DELETE CASCADE",
+                    "PRIMARY_KEY": "(post_id, tag_id)"
+                }
+            }
+        },
+        "subscription_billing": {
+            "description": "Subscription billing with plans, subscriptions, invoices",
+            "tables": {
+                "plans": {
+                    "id": "UUID PRIMARY KEY",
+                    "name": "VARCHAR(100) NOT NULL",
+                    "slug": "VARCHAR(100) UNIQUE",
+                    "price_monthly": "DECIMAL(10,2)",
+                    "price_yearly": "DECIMAL(10,2)",
+                    "features": "JSONB DEFAULT '{}'",
+                    "limits": "JSONB DEFAULT '{}'"
+                },
+                "subscriptions": {
+                    "id": "UUID PRIMARY KEY",
+                    "user_id": "UUID REFERENCES users(id)",
+                    "plan_id": "UUID REFERENCES plans(id)",
+                    "status": "ENUM('trialing','active','past_due','cancelled','expired')",
+                    "current_period_start": "TIMESTAMP",
+                    "current_period_end": "TIMESTAMP",
+                    "cancel_at_period_end": "BOOLEAN DEFAULT false"
+                },
+                "invoices": {
+                    "id": "UUID PRIMARY KEY",
+                    "subscription_id": "UUID REFERENCES subscriptions(id)",
+                    "amount": "DECIMAL(10,2)",
+                    "status": "ENUM('draft','open','paid','void')",
+                    "due_date": "TIMESTAMP",
+                    "paid_at": "TIMESTAMP"
+                }
+            }
+        }
+    },
+    "indexing_best_practices": [
+        "Always index foreign keys",
+        "Index columns used in WHERE, ORDER BY, GROUP BY",
+        "Use composite indexes for multi-column queries (most selective first)",
+        "Avoid indexing low-cardinality columns alone",
+        "Use partial indexes for filtered queries (WHERE status = 'active')",
+        "Consider GIN indexes for JSONB columns"
+    ]
+}

package/assets/.agent/skills/db-designer/scripts/sql_gen.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+Database Designer — Generate SQL / Prisma Schemas.
+
+Usage:
+    python sql_gen.py --models "User, Product" --format prisma
+"""
+
+import argparse
+
+TEMPLATES = {
+    "User": {
+        "sql": """CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    email VARCHAR(255) UNIQUE NOT NULL,
+    password_hash VARCHAR(255) NOT NULL,
+    full_name VARCHAR(100),
+    role VARCHAR(20) DEFAULT 'user',
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);""",
+        "prisma": """model User {
+  id        Int      @id @default(autoincrement())
+  email     String   @unique
+  password  String
+  fullName  String?
+  role      String   @default("user")
+  createdAt DateTime @default(now())
+  posts     Post[]
+  orders    Order[]
+}"""
+    },
+    "Product": {
+        "sql": """CREATE TABLE products (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(255) NOT NULL,
+    slug VARCHAR(255) UNIQUE,
+    price DECIMAL(10, 2) NOT NULL,
+    stock INT DEFAULT 0,
+    description TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);""",
+        "prisma": """model Product {
+  id          Int      @id @default(autoincrement())
+  name        String
+  slug        String   @unique
+  price       Decimal
+  stock       Int      @default(0)
+  description String?
+  createdAt   DateTime @default(now())
+  orderItems  OrderItem[]
+}"""
+    }
+}
+
+def generate_schema(models, fmt):
+    model_list = [m.strip() for m in models.split(",")]
+    
+    print("\n" + "="*50)
+    print(f"🗄️  GENERATED {fmt.upper()} SCHEMA")
+    print("="*50 + "\n")
+    
+    for m in model_list:
+        # Match case insensitive
+        found = False
+        for k, v in TEMPLATES.items():
+            if k.lower() == m.lower():
+                print(v.get(fmt, f"-- No template for {m} in {fmt}"))
+                print("")
+                found = True
+                break
+        
+        if not found:
+            # Generic fallback
+            if fmt == "sql":
+                print(f"CREATE TABLE {m.lower()}s (id SERIAL PRIMARY KEY, name VARCHAR(255));")
+            elif fmt == "prisma":
+                print(f"model {m} {{\n  id Int @id @default(autoincrement())\n}}")
+                
+    print("\n" + "="*50)
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--models", type=str, required=True)
+    parser.add_argument("--format", type=str, choices=["sql", "prisma"], default="sql")
+    
+    args = parser.parse_args()
+    generate_schema(args.models, args.format)
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/dbt-transformation-patterns/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: dbt-transformation-patterns
+description: Master dbt (data build tool) for analytics engineering with model organization, testing, documentation, and incremental strategies. Use when building data transformations, creating data models, or implementing analytics engineering best practices.
+---
+
+# dbt Transformation Patterns
+
+Production-ready patterns for dbt (data build tool) including model organization, testing strategies, documentation, and incremental processing.
+
+## Use this skill when
+
+- Building data transformation pipelines with dbt
+- Organizing models into staging, intermediate, and marts layers
+- Implementing data quality tests and documentation
+- Creating incremental models for large datasets
+- Setting up dbt project structure and conventions
+
+## Do not use this skill when
+
+- The project is not using dbt or a warehouse-backed workflow
+- You only need ad-hoc SQL queries
+- There is no access to source data or schemas
+
+## Instructions
+
+- Define model layers, naming, and ownership.
+- Implement tests, documentation, and freshness checks.
+- Choose materializations and incremental strategies.
+- Optimize runs with selectors and CI workflows.
+- If detailed patterns are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed dbt patterns and examples.