gkt-node 3.3.0

package/assets/.agent/skills/tech-stack-advisor/scripts/advisor.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Tech Stack Advisor — Compare and Recommend Technologies.
+
+Usage:
+    python advisor.py --category web --keywords "seo,fast"
+    python advisor.py --compare --category frontend
+    python advisor.py --list
+    python advisor.py --category ai_ml --keywords "rag,enterprise"
+"""
+
+import argparse
+import json
+from pathlib import Path
+
+DATA_FILE = Path(__file__).parent.parent / "data" / "tech_data.json"
+STACKS_FILE = Path(__file__).parent.parent / "data" / "stacks.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 load_stacks():
+    if not STACKS_FILE.exists():
+        return []
+    with open(STACKS_FILE, "r", encoding="utf-8") as f:
+        return json.load(f)
+
+def list_categories():
+    """List all available categories and their tech count."""
+    data = load_data()
+    stacks = load_stacks()
+
+    print("\n" + "=" * 60)
+    print("📂 AVAILABLE CATEGORIES")
+    print("=" * 60)
+
+    cats = data.get("categories", {})
+    for cat, items in cats.items():
+        print(f"  {cat:<15} — {len(items)} technologies")
+
+    # Count stacks by category
+    stack_cats = {}
+    for s in stacks:
+        c = s.get("category", "other")
+        stack_cats[c] = stack_cats.get(c, 0) + 1
+
+    print(f"\n📦 FULL-STACK COMBOS: {len(stacks)} total")
+    for c, count in sorted(stack_cats.items()):
+        print(f"  {c:<15} — {count} stacks")
+
+    print("\n" + "=" * 60 + "\n")
+
+def recommend(category, keywords):
+    data = load_data()
+
+    print("\n" + "=" * 60)
+    print(f"🤖 TECH RECOMMENDATION: {category.upper()}")
+    print(f"   Keywords: {keywords}")
+    print("=" * 60)
+
+    # Map 'web' to multiple categories
+    cat_map = {
+        "web": ["frontend", "backend", "database"],
+        "fullstack": ["frontend", "backend", "database", "devops"],
+        "all": list(data.get("categories", {}).keys())
+    }
+
+    categories = cat_map.get(category, [category])
+    found = False
+
+    for cat in categories:
+        options = data.get("categories", {}).get(cat, {})
+        if not options:
+            continue
+
+        found = True
+        print(f"\n📂 {cat.upper()} ({len(options)} options):")
+
+        # Score each option by keyword match
+        scored = []
+        for key, info in options.items():
+            score = 0
+            text = " ".join([
+                info.get("description", ""),
+                " ".join(info.get("pros", [])),
+                " ".join(info.get("use_cases", [])),
+                info.get("type", "")
+            ]).lower()
+
+            for k in keywords.lower().split(","):
+                k = k.strip()
+                if k and k in text:
+                    score += 1
+
+            scored.append((score, info))
+
+        scored.sort(key=lambda x: (-x[0], -x[1].get("popularity", 0)))
+
+        for score, info in scored[:3]:
+            marker = "⭐" if score > 0 else "  "
+            print(f"   {marker} {info['name']} (match: {score}, pop: {info.get('popularity', '?')})")
+            print(f"      {info.get('description', '')}")
+            if info.get("use_cases"):
+                print(f"      Best for: {', '.join(info['use_cases'][:3])}")
+
+    if not found:
+        cats = list(data.get("categories", {}).keys())
+        print(f"\n⚠️  Category '{category}' not found.")
+        print(f"   Available: {', '.join(cats)}")
+        print(f"   Or use: web, fullstack, all")
+
+    print("\n" + "=" * 60 + "\n")
+
+def recommend_stack(keywords):
+    """Recommend full-stack combos from stacks.json."""
+    stacks = load_stacks()
+
+    print("\n" + "=" * 60)
+    print(f"📦 STACK RECOMMENDATION")
+    print(f"   Keywords: {keywords}")
+    print("=" * 60)
+
+    scored = []
+    for stack in stacks:
+        score = 0
+        text = " ".join([
+            stack.get("name", ""),
+            " ".join(stack.get("tags", [])),
+            stack.get("best_for", ""),
+            " ".join(stack.get("pros", []))
+        ]).lower()
+
+        for k in keywords.lower().split(","):
+            k = k.strip()
+            if k and k in text:
+                score += 1
+
+        if score > 0:
+            scored.append((score, stack))
+
+    scored.sort(key=lambda x: x[0], reverse=True)
+
+    if not scored:
+        print("\n⚠️  No matching stacks found. Try different keywords.")
+    else:
+        for score, s in scored[:5]:
+            print(f"\n⭐ {s['name']} (match: {score})")
+            print(f"   Category: {s.get('category', '?')}")
+            comps = s.get("components", {})
+            for k, v in comps.items():
+                print(f"   {k}: {v}")
+            print(f"   Best for: {s.get('best_for', '?')}")
+
+    print("\n" + "=" * 60 + "\n")
+
+def compare(category):
+    data = load_data()
+
+    print("\n" + "=" * 60)
+    print(f"⚖️  TECH COMPARISON: {category.upper()}")
+    print("=" * 60)
+
+    options = data.get("categories", {}).get(category, {})
+
+    if not options:
+        cats = list(data.get("categories", {}).keys())
+        print(f"\n⚠️  Category '{category}' not found.")
+        print(f"   Available: {', '.join(cats)}")
+    else:
+        for key, info in options.items():
+            print(f"\n🔹 {info['name']} ({info.get('type', '-')})")
+            print(f"   ✅ Pros: {', '.join(info.get('pros', []))}")
+            print(f"   ❌ Cons: {', '.join(info.get('cons', []))}")
+            print(f"   💡 Best for: {', '.join(info.get('use_cases', []))}")
+            print(f"   📊 Popularity: {info.get('popularity', '?')}")
+
+    print("\n" + "=" * 60 + "\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="Tech Stack Advisor")
+    parser.add_argument("--category", "-c", type=str, help="Category: frontend, backend, database, mobile, devops, ai_ml, auth, testing, messaging, cms, web, fullstack, all")
+    parser.add_argument("--keywords", "-k", type=str, default="", help="Comma-separated keywords for scoring")
+    parser.add_argument("--compare", action="store_true", help="Show comparison view for a category")
+    parser.add_argument("--stack", "-s", action="store_true", help="Recommend full-stack combos (searches stacks.json)")
+    parser.add_argument("--list", "-l", action="store_true", help="List all available categories")
+    parser.add_argument("--json", "-j", action="store_true", help="Output raw JSON")
+
+    args = parser.parse_args()
+
+    if args.list:
+        list_categories()
+    elif args.stack:
+        if not args.keywords:
+            print("⚠️  Use --keywords with --stack. Example: --stack --keywords 'seo,react'")
+        else:
+            recommend_stack(args.keywords)
+    elif args.compare:
+        if not args.category:
+            print("⚠️  Use --category with --compare. Example: --compare --category frontend")
+        else:
+            compare(args.category)
+    elif args.category:
+        recommend(args.category, args.keywords)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/tech-stack-advisor/scripts/scanner.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""
+Tech Stack Scanner — Analyze existing codebase to detect stack.
+
+Usage:
+    python scanner.py --path "."
+"""
+
+import argparse
+import os
+import json
+from pathlib import Path
+from collections import Counter
+
+IGNORED_DIRS = {
+    "node_modules", ".git", "__pycache__", "dist", "build", "venv", "env", ".idea", ".vscode", "target", "vendor"
+}
+
+STACK_INDICATORS = {
+    "package.json": "Node.js / JS Ecosystem",
+    "requirements.txt": "Python",
+    "pyproject.toml": "Python (Poetry/Modern)",
+    "pom.xml": "Java (Maven)",
+    "build.gradle": "Java/Android (Gradle)",
+    "composer.json": "PHP (Composer)",
+    "go.mod": "Go",
+    "Cargo.toml": "Rust",
+    "Gemfile": "Ruby",
+    "mix.exs": "Elixir",
+    "Dockerfile": "Dockerized",
+    "docker-compose.yml": "Docker Compose",
+    "next.config.js": "Next.js",
+    "nuxt.config.js": "Nuxt.js",
+    "vite.config.js": "Vite",
+    "tsconfig.json": "TypeScript"
+}
+
+def scan_codebase(root_path):
+    root_path = Path(root_path)
+    extension_counts = Counter()
+    config_files = []
+    
+    print(f"🔍 Scanning tech stack at: {root_path}")
+    
+    for root, dirs, files in os.walk(root_path):
+        dirs[:] = [d for d in dirs if d not in IGNORED_DIRS]
+        
+        for file in files:
+            if file in STACK_INDICATORS:
+                config_files.append(f"{file} ({STACK_INDICATORS[file]})")
+                
+            ext = Path(file).suffix.lower()
+            if ext:
+                extension_counts[ext] += 1
+                
+    print("\n" + "="*50)
+    print("📊 TECH STACK REPORT")
+    print("="*50)
+    
+    print("\n🛠️  Configuration Files Detected:")
+    if config_files:
+        for cf in set(config_files): # Deduplicate
+            print(f"   - {cf}")
+    else:
+        print("   (None)")
+        
+    print("\n📁 File Extensions Distribution:")
+    total_files = sum(extension_counts.values())
+    if total_files > 0:
+        for ext, count in extension_counts.most_common(5):
+            percent = (count / total_files) * 100
+            print(f"   {ext}: {count} files ({percent:.1f}%)")
+    else:
+        print("   (No files found)")
+
+    # Inference
+    print("\n🧠 Inference:")
+    stack = []
+    if "package.json" in [f.split()[0] for f in config_files]:
+        if "next.config.js" in [f.split()[0] for f in config_files]:
+            stack.append("Next.js Fullstack")
+        else:
+            stack.append("Node.js / Web")
+            
+    if ".py" in extension_counts:
+        stack.append("Python")
+        
+    if not stack:
+        stack.append("Generic / Unknown")
+        
+    print(f"   Likely Stack: {', '.join(stack)}")
+    print("="*50 + "\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="Tech Stack Scanner")
+    parser.add_argument("--path", type=str, default=".", help="Path to scan")
+    
+    args = parser.parse_args()
+    scan_codebase(args.path)
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/terraform-module-library/SKILL.md

@@ -0,0 +1,261 @@
+---
+name: terraform-module-library
+description: Build reusable Terraform modules for AWS, Azure, and GCP infrastructure following infrastructure-as-code best practices. Use when creating infrastructure modules, standardizing cloud provisioning, or implementing reusable IaC components.
+---
+
+# Terraform Module Library
+
+Production-ready Terraform module patterns for AWS, Azure, and GCP infrastructure.
+
+## Do not use this skill when
+
+- The task is unrelated to terraform module library
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Purpose
+
+Create reusable, well-tested Terraform modules for common cloud infrastructure patterns across multiple cloud providers.
+
+## Use this skill when
+
+- Build reusable infrastructure components
+- Standardize cloud resource provisioning
+- Implement infrastructure as code best practices
+- Create multi-cloud compatible modules
+- Establish organizational Terraform standards
+
+## Module Structure
+
+```
+terraform-modules/
+├── aws/
+│   ├── vpc/
+│   ├── eks/
+│   ├── rds/
+│   └── s3/
+├── azure/
+│   ├── vnet/
+│   ├── aks/
+│   └── storage/
+└── gcp/
+    ├── vpc/
+    ├── gke/
+    └── cloud-sql/
+```
+
+## Standard Module Pattern
+
+```
+module-name/
+├── main.tf          # Main resources
+├── variables.tf     # Input variables
+├── outputs.tf       # Output values
+├── versions.tf      # Provider versions
+├── README.md        # Documentation
+├── examples/        # Usage examples
+│   └── complete/
+│       ├── main.tf
+│       └── variables.tf
+└── tests/           # Terratest files
+    └── module_test.go
+```
+
+## AWS VPC Module Example
+
+**main.tf:**
+```hcl
+resource "aws_vpc" "main" {
+  cidr_block           = var.cidr_block
+  enable_dns_hostnames = var.enable_dns_hostnames
+  enable_dns_support   = var.enable_dns_support
+
+  tags = merge(
+    {
+      Name = var.name
+    },
+    var.tags
+  )
+}
+
+resource "aws_subnet" "private" {
+  count             = length(var.private_subnet_cidrs)
+  vpc_id            = aws_vpc.main.id
+  cidr_block        = var.private_subnet_cidrs[count.index]
+  availability_zone = var.availability_zones[count.index]
+
+  tags = merge(
+    {
+      Name = "${var.name}-private-${count.index + 1}"
+      Tier = "private"
+    },
+    var.tags
+  )
+}
+
+resource "aws_internet_gateway" "main" {
+  count  = var.create_internet_gateway ? 1 : 0
+  vpc_id = aws_vpc.main.id
+
+  tags = merge(
+    {
+      Name = "${var.name}-igw"
+    },
+    var.tags
+  )
+}
+```
+
+**variables.tf:**
+```hcl
+variable "name" {
+  description = "Name of the VPC"
+  type        = string
+}
+
+variable "cidr_block" {
+  description = "CIDR block for VPC"
+  type        = string
+  validation {
+    condition     = can(regex("^([0-9]{1,3}\\.){3}[0-9]{1,3}/[0-9]{1,2}$", var.cidr_block))
+    error_message = "CIDR block must be valid IPv4 CIDR notation."
+  }
+}
+
+variable "availability_zones" {
+  description = "List of availability zones"
+  type        = list(string)
+}
+
+variable "private_subnet_cidrs" {
+  description = "CIDR blocks for private subnets"
+  type        = list(string)
+  default     = []
+}
+
+variable "enable_dns_hostnames" {
+  description = "Enable DNS hostnames in VPC"
+  type        = bool
+  default     = true
+}
+
+variable "tags" {
+  description = "Additional tags"
+  type        = map(string)
+  default     = {}
+}
+```
+
+**outputs.tf:**
+```hcl
+output "vpc_id" {
+  description = "ID of the VPC"
+  value       = aws_vpc.main.id
+}
+
+output "private_subnet_ids" {
+  description = "IDs of private subnets"
+  value       = aws_subnet.private[*].id
+}
+
+output "vpc_cidr_block" {
+  description = "CIDR block of VPC"
+  value       = aws_vpc.main.cidr_block
+}
+```
+
+## Best Practices
+
+1. **Use semantic versioning** for modules
+2. **Document all variables** with descriptions
+3. **Provide examples** in examples/ directory
+4. **Use validation blocks** for input validation
+5. **Output important attributes** for module composition
+6. **Pin provider versions** in versions.tf
+7. **Use locals** for computed values
+8. **Implement conditional resources** with count/for_each
+9. **Test modules** with Terratest
+10. **Tag all resources** consistently
+
+## Module Composition
+
+```hcl
+module "vpc" {
+  source = "../../modules/aws/vpc"
+
+  name               = "production"
+  cidr_block         = "10.0.0.0/16"
+  availability_zones = ["us-west-2a", "us-west-2b", "us-west-2c"]
+
+  private_subnet_cidrs = [
+    "10.0.1.0/24",
+    "10.0.2.0/24",
+    "10.0.3.0/24"
+  ]
+
+  tags = {
+    Environment = "production"
+    ManagedBy   = "terraform"
+  }
+}
+
+module "rds" {
+  source = "../../modules/aws/rds"
+
+  identifier     = "production-db"
+  engine         = "postgres"
+  engine_version = "15.3"
+  instance_class = "db.t3.large"
+
+  vpc_id     = module.vpc.vpc_id
+  subnet_ids = module.vpc.private_subnet_ids
+
+  tags = {
+    Environment = "production"
+  }
+}
+```
+
+## Reference Files
+
+- `assets/vpc-module/` - Complete VPC module example
+- `assets/rds-module/` - RDS module example
+- `references/aws-modules.md` - AWS module patterns
+- `references/azure-modules.md` - Azure module patterns
+- `references/gcp-modules.md` - GCP module patterns
+
+## Testing
+
+```go
+// tests/vpc_test.go
+package test
+
+import (
+    "testing"
+    "github.com/gruntwork-io/terratest/modules/terraform"
+    "github.com/stretchr/testify/assert"
+)
+
+func TestVPCModule(t *testing.T) {
+    terraformOptions := &terraform.Options{
+        TerraformDir: "../examples/complete",
+    }
+
+    defer terraform.Destroy(t, terraformOptions)
+    terraform.InitAndApply(t, terraformOptions)
+
+    vpcID := terraform.Output(t, terraformOptions, "vpc_id")
+    assert.NotEmpty(t, vpcID)
+}
+```
+
+## Related Skills
+
+- `multi-cloud-architecture` - For architectural decisions
+- `cost-optimization` - For cost-effective designs

package/assets/.agent/skills/terraform-module-library/references/aws-modules.md

@@ -0,0 +1,63 @@
+# AWS Terraform Module Patterns
+
+## VPC Module
+- VPC with public/private subnets
+- Internet Gateway and NAT Gateways
+- Route tables and associations
+- Network ACLs
+- VPC Flow Logs
+
+## EKS Module
+- EKS cluster with managed node groups
+- IRSA (IAM Roles for Service Accounts)
+- Cluster autoscaler
+- VPC CNI configuration
+- Cluster logging
+
+## RDS Module
+- RDS instance or cluster
+- Automated backups
+- Read replicas
+- Parameter groups
+- Subnet groups
+- Security groups
+
+## S3 Module
+- S3 bucket with versioning
+- Encryption at rest
+- Bucket policies
+- Lifecycle rules
+- Replication configuration
+
+## ALB Module
+- Application Load Balancer
+- Target groups
+- Listener rules
+- SSL/TLS certificates
+- Access logs
+
+## Lambda Module
+- Lambda function
+- IAM execution role
+- CloudWatch Logs
+- Environment variables
+- VPC configuration (optional)
+
+## Security Group Module
+- Reusable security group rules
+- Ingress/egress rules
+- Dynamic rule creation
+- Rule descriptions
+
+## Best Practices
+
+1. Use AWS provider version ~> 5.0
+2. Enable encryption by default
+3. Use least-privilege IAM
+4. Tag all resources consistently
+5. Enable logging and monitoring
+6. Use KMS for encryption
+7. Implement backup strategies
+8. Use PrivateLink when possible
+9. Enable GuardDuty/SecurityHub
+10. Follow AWS Well-Architected Framework