gkt-node 3.3.0

package/assets/.agent/skills/system-diagrammer/data/diagram_templates.json

@@ -0,0 +1,69 @@
+{
+    "diagram_templates": {
+        "c4_context": {
+            "type": "C4 Context Diagram",
+            "mermaid_template": "C4Context\n  title System Context Diagram - {system_name}\n  Person(user, \"{user_name}\", \"{user_desc}\")\n  System(system, \"{system_name}\", \"{system_desc}\")\n  System_Ext(ext, \"{external_name}\", \"{external_desc}\")\n  Rel(user, system, \"Uses\")\n  Rel(system, ext, \"Calls API\")",
+            "use_case": "Show how the system fits into the world"
+        },
+        "c4_container": {
+            "type": "C4 Container Diagram",
+            "mermaid_template": "C4Container\n  title Container Diagram - {system_name}\n  Person(user, \"User\")\n  Container(web, \"Web App\", \"React\", \"SPA frontend\")\n  Container(api, \"API Server\", \"Node.js\", \"REST API\")\n  ContainerDb(db, \"Database\", \"PostgreSQL\", \"Stores data\")\n  Rel(user, web, \"Uses\", \"HTTPS\")\n  Rel(web, api, \"Calls\", \"JSON/HTTPS\")\n  Rel(api, db, \"Reads/Writes\", \"SQL\")",
+            "use_case": "Show containers within the system"
+        },
+        "sequence": {
+            "type": "Sequence Diagram",
+            "mermaid_template": "sequenceDiagram\n  actor User\n  participant Frontend\n  participant API\n  participant DB\n  User->>Frontend: {action}\n  Frontend->>API: {request}\n  API->>DB: {query}\n  DB-->>API: {result}\n  API-->>Frontend: {response}\n  Frontend-->>User: {display}",
+            "use_case": "Show interaction flow between components"
+        },
+        "er_diagram": {
+            "type": "Entity Relationship Diagram",
+            "mermaid_template": "erDiagram\n  USERS ||--o{ ORDERS : places\n  ORDERS ||--|{ ORDER_ITEMS : contains\n  PRODUCTS ||--o{ ORDER_ITEMS : \"included in\"",
+            "use_case": "Show database relationships"
+        },
+        "flowchart": {
+            "type": "Process Flowchart",
+            "mermaid_template": "flowchart TD\n  A[Start] --> B{Condition?}\n  B -->|Yes| C[Action 1]\n  B -->|No| D[Action 2]\n  C --> E[End]\n  D --> E",
+            "use_case": "Show process or decision flow"
+        },
+        "state_diagram": {
+            "type": "State Machine",
+            "mermaid_template": "stateDiagram-v2\n  [*] --> Draft\n  Draft --> Published: Publish\n  Published --> Archived: Archive\n  Archived --> Draft: Restore\n  Published --> Draft: Unpublish",
+            "use_case": "Show state transitions (order status, user lifecycle)"
+        },
+        "deployment": {
+            "type": "Deployment Architecture",
+            "mermaid_template": "graph LR\n  subgraph CDN\n    CF[CloudFront]\n  end\n  subgraph Compute\n    ECS[ECS/Fargate]\n  end\n  subgraph Data\n    RDS[(RDS PostgreSQL)]\n    Redis[(ElastiCache)]\n    S3[S3 Bucket]\n  end\n  CF --> ECS\n  ECS --> RDS\n  ECS --> Redis\n  ECS --> S3",
+            "use_case": "Show cloud infrastructure layout"
+        }
+    },
+    "icon_sets": {
+        "aws": [
+            "EC2",
+            "ECS",
+            "Lambda",
+            "RDS",
+            "S3",
+            "CloudFront",
+            "SQS",
+            "SNS",
+            "DynamoDB"
+        ],
+        "gcp": [
+            "GCE",
+            "GKE",
+            "Cloud Run",
+            "Cloud SQL",
+            "GCS",
+            "Pub/Sub",
+            "BigQuery"
+        ],
+        "azure": [
+            "App Service",
+            "AKS",
+            "Functions",
+            "SQL Database",
+            "Blob Storage",
+            "Service Bus"
+        ]
+    }
+}

package/assets/.agent/skills/system-diagrammer/scripts/diagram.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+System Diagrammer — Generate Mermaid.js Architecture Diagrams.
+
+Usage:
+    python diagram.py --type c4 --title "E-commerce System" --nodes "User, Web App, API, Database"
+    python diagram.py --type sequence --title "Login Flow" --steps "User->Web:Login, Web->API:Auth Request, API->DB:Check Creds"
+"""
+
+import argparse
+import sys
+
+def generate_c4(title, nodes_str):
+    nodes = [n.strip() for n in nodes_str.split(",")]
+    lines = [f"title {title}", "throughput", "User((User))"]
+    
+    # Simple C4 Context styling
+    for i, node in enumerate(nodes):
+        if node.lower() == "user": continue
+        
+        # Simple heuristic for shape
+        shape = "rect" 
+        if "db" in node.lower() or "database" in node.lower(): shape = "db"
+        
+        node_id = node.replace(" ", "_")
+        
+        if shape == "db":
+            lines.append(f"    {node_id}[({node})]")
+        else:
+            lines.append(f"    {node_id}[{node}]")
+            
+    # Connect them sequentially for now (simple chain)
+    lines.append("    User --> " + nodes[1].replace(" ", "_"))
+    for i in range(1, len(nodes)-1):
+        if nodes[i].lower() == "user": continue
+        current = nodes[i].replace(" ", "_")
+        next_n = nodes[i+1].replace(" ", "_")
+        lines.append(f"    {current} --> {next_n}")
+        
+    return "graph TD\n" + "\n".join(lines)
+
+def generate_sequence(title, steps_str):
+    steps = [s.strip() for s in steps_str.split(",")]
+    lines = [f"title {title}", "autonumber"]
+    
+    for step in steps:
+        if ":" in step and "->" in step:
+            # Format: A->B:Message
+            parts = step.split(":")
+            interaction = parts[0].strip()
+            message = parts[1].strip()
+            lines.append(f"    {interaction}: {message}")
+        else:
+            lines.append(f"    Note over User: {step}")
+            
+    return "sequenceDiagram\n" + "\n".join(lines)
+
+def main():
+    parser = argparse.ArgumentParser(description="System Diagrammer")
+    parser.add_argument("--type", type=str, required=True, choices=["c4", "sequence"], help="Diagram type")
+    parser.add_argument("--title", type=str, default="System Diagram", help="Diagram title")
+    parser.add_argument("--nodes", type=str, help="List of nodes for C4 (comma separated)")
+    parser.add_argument("--steps", type=str, help="List of steps for Sequence (A->B:Msg, ...)")
+    
+    args = parser.parse_args()
+    
+    print("```mermaid")
+    if args.type == "c4":
+        if not args.nodes:
+            print("Error: --nodes required for C4")
+        else:
+            print(generate_c4(args.title, args.nodes))
+    elif args.type == "sequence":
+        if not args.steps:
+            print("Error: --steps required for Sequence")
+        else:
+            print(generate_sequence(args.title, args.steps))
+    print("```")
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/system-strategist/SKILL.md

@@ -0,0 +1,35 @@
+---
+name: system-strategist
+description: High-level decision maker for Trade-offs, Scalability & Migration Strategy.
+---
+
+# System Strategist
+
+## Purpose
+Assists Architect in making difficult decisions (Trade-offs), planning for growth (Scalability), and system transition strategies (Migration).
+
+## Usage
+
+### 1. Tradeoff Evaluator
+Compare technical choices (SQL vs NoSQL, Monolith vs Microservices...).
+```bash
+python .agent/skills/system-strategist/scripts/strategist.py --type tradeoff --topic "sql_vs_nosql"
+```
+
+### 2. Scalability Planner
+Propose infrastructure solutions based on expected user count.
+```bash
+python .agent/skills/system-strategist/scripts/strategist.py --type scalability --users 100000
+```
+*Output: Caching, Read Replicas, Worker Queues...*
+
+### 3. Migration Strategist
+Choose safe deployment or migration strategies (Strangler Fig, Blue-Green, Canary).
+```bash
+python .agent/skills/system-strategist/scripts/strategist.py --type migration --strategy "strangler_fig"
+```
+
+## Supported Topics
+- **Trade-offs**: `sql_vs_nosql`, `monolith_vs_microservices`, `rest_vs_graphql`
+- **Scalability**: 10k, 100k, 1M+ users logic
+- **Migration**: `strangler_fig`, `blue_green`, `canary`

package/assets/.agent/skills/system-strategist/data/strategy_patterns.json

@@ -0,0 +1,170 @@
+{
+    "tradeoffs": {
+        "sql_vs_nosql": {
+            "context": "Choosing primary database",
+            "options": [
+                {
+                    "name": "SQL (Relational)",
+                    "pros": [
+                        "ACID compliance",
+                        "Standardized query language",
+                        "Rich join capabilities"
+                    ],
+                    "cons": [
+                        "Harder to scale horizontally",
+                        "Rigid schema"
+                    ],
+                    "best_for": "Financial systems, ERP, CRM"
+                },
+                {
+                    "name": "NoSQL (Document/Key-Value)",
+                    "pros": [
+                        "Flexible schema",
+                        "Easy horizontal scaling",
+                        "High write throughput"
+                    ],
+                    "cons": [
+                        "Eventual consistency",
+                        "Limited join capabilities"
+                    ],
+                    "best_for": "Content management, Real-time feeds, IoT"
+                }
+            ],
+            "decision_matrix": "If data is structured and consistency is critical -> SQL. If data is unstructured and speed/scale is priority -> NoSQL."
+        },
+        "monolith_vs_microservices": {
+            "context": "System Architecture Style",
+            "options": [
+                {
+                    "name": "Monolith",
+                    "pros": [
+                        "Simple to deploy",
+                        "Easy debugging",
+                        "Low latency (in-memory calls)"
+                    ],
+                    "cons": [
+                        "Hard to scale parts independently",
+                        "Tight coupling",
+                        "Technology lock-in"
+                    ],
+                    "best_for": "Startups, MVP, Small-Medium teams"
+                },
+                {
+                    "name": "Microservices",
+                    "pros": [
+                        "Independent scaling",
+                        "Tech stack flexibility",
+                        "Fault isolation"
+                    ],
+                    "cons": [
+                        "Complex operations (DevOps)",
+                        "Network latency",
+                        "Distributed data consistency issues"
+                    ],
+                    "best_for": "Large enterprises, High scale, multiple independent teams"
+                }
+            ],
+            "decision_matrix": "Start with Monolith. Break into Microservices only when team size > 10 or specific components need independent scaling."
+        },
+        "rest_vs_graphql": {
+            "context": "API Style",
+            "options": [
+                {
+                    "name": "REST",
+                    "pros": [
+                        "Standard caching",
+                        "Simple tooling",
+                        "Resource-oriented"
+                    ],
+                    "cons": [
+                        "Over-fetching/Under-fetching",
+                        "Multiple round-trips"
+                    ],
+                    "best_for": "Public APIs, Simple CRUD, Caching-heavy apps"
+                },
+                {
+                    "name": "GraphQL",
+                    "pros": [
+                        "Exact data fetching",
+                        "Single endpoint",
+                        "Strongly typed"
+                    ],
+                    "cons": [
+                        "Complex caching",
+                        "N+1 query performance risks",
+                        "Learning curve"
+                    ],
+                    "best_for": "Complex UI data requirements, Mobile apps, Aggregating multiple sources"
+                }
+            ],
+            "decision_matrix": "Use REST for simplicity and public APIs. Use GraphQL for complex, data-rich frontends."
+        }
+    },
+    "scalability_plans": {
+        "10k_users": {
+            "focus": "Vertical Scaling & Basics",
+            "strategies": [
+                "Optimize Database Indexes (Low hanging fruit)",
+                "Upgrade Server Specs (Vertical Scaling)",
+                "Implement basic CDN for static assets",
+                "Use a managed database service (RDS/Supabase)"
+            ]
+        },
+        "100k_users": {
+            "focus": "Horizontal Scaling & Caching",
+            "strategies": [
+                "Add Read Replicas for Database",
+                "Implement Redis/Memcached for hot data",
+                "Load Balancer (Nginx/AWS ALB) with multiple App Servers",
+                "Asynchronous processing (Worker Queues) for heavy tasks"
+            ]
+        },
+        "1m_users": {
+            "focus": "Sharding & Distribution",
+            "strategies": [
+                "Database Sharding (Horizontal Partitioning)",
+                "Multi-region deployment (Geo-DNS)",
+                "Event-driven Architecture (Kafka/RabbitMQ)",
+                "Circuit Breakers & Rate Limiting"
+            ]
+        }
+    },
+    "migration_strategies": {
+        "strangler_fig": {
+            "name": "Strangler Fig Pattern",
+            "description": "Gradually replace specific functionalities of the legacy system with new applications and services.",
+            "steps": [
+                "Identify edge functionality to carve out.",
+                "Build new microservice for that functionality.",
+                "Route traffic to new service via proxy.",
+                "Repeat until legacy system is strangled."
+            ],
+            "pros": "Low risk, incremental value.",
+            "cons": "Complexity of managing two systems."
+        },
+        "blue_green": {
+            "name": "Blue-Green Deployment",
+            "description": "Two identical environments. Blue is live. Deploy to Green. Switch router to Green.",
+            "steps": [
+                "Deploy new version to Green environment.",
+                "Run smoke tests on Green.",
+                "Switch Load Balancer to point to Green.",
+                "Monitor for errors. Rollback to Blue if needed."
+            ],
+            "pros": "Zero downtime, instant rollback.",
+            "cons": "Double infrastructure cost."
+        },
+        "canary": {
+            "name": "Canary Release",
+            "description": "Roll out to a small subset of users (e.g. 5%) before full rollout.",
+            "steps": [
+                "Deploy to Canary instance.",
+                "Route 5% of traffic to Canary.",
+                "Monitor metrics (Error rate, Latency).",
+                "Gradually increase traffic (10%, 25%, 50%, 100%)."
+            ],
+            "pros": "Limits blast radius of bugs.",
+            "cons": "Complex routing & monitoring setup."
+        }
+    }
+}

package/assets/.agent/skills/system-strategist/scripts/strategist.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+System Strategist — Provide high-level architectural decisions and strategies.
+
+Usage:
+    python strategist.py --type tradeoff --topic "sql_vs_nosql"
+    python strategist.py --type scalability --users 100000
+    python strategist.py --type migration --strategy "strangler_fig"
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Path to data
+DATA_FILE = Path(__file__).parent.parent / "data" / "strategy_patterns.json"
+
+def load_data():
+    if not DATA_FILE.exists():
+        return {}
+    with open(DATA_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def show_tradeoff(topic):
+    data = load_data()
+    tradeoffs = data.get("tradeoffs", {})
+    
+    # Partial match search
+    item = None
+    for key in tradeoffs:
+        if topic.lower() in key.lower():
+            item = tradeoffs[key]
+            topic = key # Correct naming
+            break
+            
+    if not item:
+        print(f"❌ Topic '{topic}' not found in tradeoffs.")
+        print(f"   Available: {', '.join(tradeoffs.keys())}")
+        return
+
+    print("\n" + "="*60)
+    print(f"⚖️  TRADEOFF EVALUATION: {topic.upper().replace('_', ' ')}")
+    print(f"   Context: {item['context']}")
+    print("="*60)
+    
+    for opt in item["options"]:
+        print(f"\n🔹 Option: {opt['name']}")
+        print("   ✅ Pros:")
+        for p in opt['pros']: print(f"      + {p}")
+        print("   ⚠️ Cons:")
+        for c in opt['cons']: print(f"      - {c}")
+        print(f"   🎯 Best For: {opt['best_for']}")
+
+    print("\n💡 DECISION MATRIX:")
+    print(f"   {item['decision_matrix']}")
+    print("="*60 + "\n")
+
+def plan_scalability(users):
+    data = load_data()
+    plans = data.get("scalability_plans", {})
+    
+    # Determine tier
+    tier = "10k_users"
+    if users >= 1000000: tier = "1m_users"
+    elif users >= 100000: tier = "100k_users"
+    
+    plan = plans.get(tier)
+    
+    print("\n" + "="*60)
+    print(f"📈 SCALABILITY PLAN FOR {users:,} USERS")
+    print(f"   Focus: {plan['focus']}")
+    print("="*60)
+    
+    print("\n🚀 Recommended Strategies:")
+    for idx, strategy in enumerate(plan['strategies'], 1):
+        print(f"   {idx}. {strategy}")
+        
+    print("\n" + "="*60 + "\n")
+
+def plan_migration(strategy_name):
+    data = load_data()
+    migrations = data.get("migration_strategies", {})
+    
+    # Partial match
+    item = None
+    for key in migrations:
+        if strategy_name.lower() in key.lower():
+            item = migrations[key]
+            break
+            
+    if not item:
+        print(f"❌ Strategy '{strategy_name}' not found.")
+        print(f"   Available: {', '.join(migrations.keys())}")
+        return
+
+    print("\n" + "="*60)
+    print(f"🔄 MIGRATION STRATEGY: {item['name']}")
+    print("="*60)
+    print(f"\n📝 Description: {item['description']}")
+    
+    print("\n👣 Execution Steps:")
+    for idx, step in enumerate(item['steps'], 1):
+        print(f"   {idx}. {step}")
+        
+    print(f"\n✅ Pros: {item['pros']}")
+    print(f"⚠️ Cons: {item['cons']}")
+    print("="*60 + "\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="System Strategist")
+    parser.add_argument("--type", type=str, required=True, choices=["tradeoff", "scalability", "migration"], help="Type of advice")
+    parser.add_argument("--topic", type=str, help="Topic for tradeoff (e.g. sql_vs_nosql)")
+    parser.add_argument("--users", type=int, help="Number of users for scalability planning")
+    parser.add_argument("--strategy", type=str, help="Name of migration strategy")
+    
+    args = parser.parse_args()
+    
+    if args.type == "tradeoff":
+        if not args.topic:
+            print("Error: --topic required for tradeoff")
+        else:
+            show_tradeoff(args.topic)
+    elif args.type == "scalability":
+        if not args.users:
+            print("Error: --users required for scalability")
+        else:
+            plan_scalability(args.users)
+    elif args.type == "migration":
+        if not args.strategy:
+            print("Error: --strategy required for migration")
+        else:
+            plan_migration(args.strategy)
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/tavily-web/SKILL.md

@@ -0,0 +1,36 @@
+---
+name: tavily-web
+description: Web search, content extraction, crawling, and research capabilities using Tavily API
+---
+
+# tavily-web
+
+## Overview
+Web search, content extraction, crawling, and research capabilities using Tavily API
+
+## When to Use
+- When you need to search the web for current information
+- When extracting content from URLs
+- When crawling websites
+
+## Installation
+```bash
+npx skills add -g BenedictKing/tavily-web
+```
+
+## Step-by-Step Guide
+1. Install the skill using the command above
+2. Configure Tavily API key
+3. Use naturally in Claude Code conversations
+
+## Examples
+See [GitHub Repository](https://github.com/BenedictKing/tavily-web) for examples.
+
+## Best Practices
+- Configure API keys via environment variables
+
+## Troubleshooting
+See the GitHub repository for troubleshooting guides.
+
+## Related Skills
+- context7-auto-research, exa-search, firecrawl-scraper, codex-review