gkt-node 3.3.0

package/assets/.agent/skills/codebase-navigator/scripts/navigator.py

@@ -0,0 +1,240 @@
+#!/usr/bin/env python3
+"""
+Codebase Navigator — Index and Search Codebase Symbols (Token Optimized).
+
+Usage:
+    python navigator.py --action index --path "./src"
+    python navigator.py --action search --query "UserLogin"
+    python navigator.py --action map
+    python navigator.py --action outline              # Leader-friendly compact view
+"""
+
+import argparse
+import json
+import os
+import re
+from pathlib import Path
+
+# Path to index file
+INDEX_FILE = Path(__file__).parent.parent / "data" / "codebase_index.json"
+
+# Regex patterns for symbols — captures full signature line
+PATTERNS = {
+    "python": [
+        (r"^\s*(class\s+\w+[^:]*)", "class"),
+        (r"^\s*(def\s+\w+\s*\([^)]*\)[^:]*)", "function"),
+    ],
+    "javascript": [
+        (r"^\s*(class\s+\w+[^{]*)", "class"),
+        (r"^\s*((?:async\s+)?function\s+\w+\s*\([^)]*\))", "function"),
+        (r"^\s*((?:export\s+)?const\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*(?:=>)?)", "function"),
+        (r"^\s*((?:export\s+)?(?:async\s+)?\w+\s*\([^)]*\)\s*\{)", "method"),
+    ],
+    "java": [
+        (r"^\s*((?:public|private|protected)\s+class\s+\w+[^{]*)", "class"),
+        (r"^\s*((?:public|private|protected)\s+interface\s+\w+[^{]*)", "interface"),
+        (r"^\s*((?:public|private|protected)\s+\w+\s+\w+\s*\([^)]*\))", "method"),
+    ],
+    "csharp": [
+        (r"^\s*((?:public|private|protected)\s+class\s+\w+[^{]*)", "class"),
+        (r"^\s*((?:public|private|protected)\s+interface\s+\w+[^{]*)", "interface"),
+        (r"^\s*((?:public|private|protected)\s+\w+\s+\w+\s*\([^)]*\))", "method"),
+    ],
+    "go": [
+        (r"^(func\s+(?:\(\w+\s+\*?\w+\)\s+)?\w+\s*\([^)]*\)[^{]*)", "function"),
+        (r"^(type\s+\w+\s+struct)", "struct"),
+        (r"^(type\s+\w+\s+interface)", "interface"),
+    ]
+}
+
+EXTENSIONS = {
+    ".py": "python",
+    ".js": "javascript",
+    ".ts": "javascript",
+    ".jsx": "javascript",
+    ".tsx": "javascript",
+    ".java": "java",
+    ".cs": "csharp",
+    ".go": "go"
+}
+
+IGNORED_DIRS = {
+    "node_modules", ".git", "__pycache__", "dist", "build", "venv", "env", ".idea", ".vscode"
+}
+
+def load_index():
+    if not INDEX_FILE.exists():
+        return {"files": {}, "metadata": {}}
+    with open(INDEX_FILE, "r", encoding="utf-8") as f:
+        try:
+            return json.load(f)
+        except json.JSONDecodeError:
+            return {"files": {}, "metadata": {}}
+
+def save_index(index):
+    INDEX_FILE.parent.mkdir(parents=True, exist_ok=True)
+    with open(INDEX_FILE, "w", encoding="utf-8") as f:
+        json.dump(index, f, indent=2)
+
+def index_codebase(root_path, incremental=False):
+    index = load_index() if incremental else {"files": {}, "metadata": {}}
+    if "files" not in index: index["files"] = {}
+    if "metadata" not in index: index["metadata"] = {}
+    
+    root_path = Path(root_path)
+    print(f"🔍 Indexing codebase at: {root_path} (Incremental: {incremental})")
+    
+    changes = {"updated": [], "removed": [], "added": []}
+    current_files = set()
+    
+    # 1. Scan files
+    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:
+            file_path = Path(root) / file
+            rel_path = str(file_path.relative_to(root_path))
+            ext = file_path.suffix.lower()
+            
+            if ext in EXTENSIONS:
+                current_files.add(rel_path)
+                mtime = file_path.stat().st_mtime
+                
+                # Check if modified
+                last_mtime = index["metadata"].get(rel_path, 0)
+                if incremental and mtime <= last_mtime and rel_path in index["files"]:
+                    continue # Skip unchanged
+                
+                # Parse
+                lang = EXTENSIONS[ext]
+                symbols = []
+                try:
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as f:
+                        lines = f.readlines()
+                    
+                    for line_num, line in enumerate(lines, 1):
+                        for pattern, sym_type in PATTERNS[lang]:
+                            match = re.search(pattern, line)
+                            if match:
+                                signature = match.group(1).strip()
+                                # Extract just the name for searching
+                                name_match = re.search(r'(?:class|def|function|func|const|let|type)\s+(\w+)', signature)
+                                name = name_match.group(1) if name_match else signature.split('(')[0].split()[-1]
+                                symbols.append({
+                                    "name": name,
+                                    "signature": signature,
+                                    "line": line_num,
+                                    "type": sym_type
+                                })
+                    
+                    index["files"][rel_path] = symbols
+                    index["metadata"][rel_path] = mtime
+                    
+                    if rel_path in index["metadata"] and incremental:
+                         changes["updated"].append(rel_path)
+                    else:
+                         changes["added"].append(rel_path)
+                         
+                    print(f"   Indexed: {rel_path} ({len(symbols)} symbols)")
+                    
+                except Exception as e:
+                    print(f"   Error reading {file_path}: {e}")
+
+    # 2. Cleanup removed files
+    known_files = list(index["files"].keys())
+    for f in known_files:
+        if f not in current_files:
+            del index["files"][f]
+            if f in index["metadata"]: del index["metadata"][f]
+            changes["removed"].append(f)
+            print(f"   Removed: {f}")
+
+    save_index(index)
+    
+    print("\n📊 Index Report:")
+    if changes['added']: print(f"   + Added: {len(changes['added'])} files")
+    if changes['updated']: print(f"   ~ Updated: {len(changes['updated'])} files")
+    if changes['removed']: print(f"   - Removed: {len(changes['removed'])} files")
+    print("✅ Indexing complete.")
+
+def search_index(query):
+    index = load_index()
+    if not index or "files" not in index:
+        print("❌ No index found. Run --action index first.")
+        return
+
+    results = []
+    print(f"🔎 Searching for '{query}'...")
+    
+    for file_path, symbols in index.get("files", {}).items():
+        # Match file name
+        if query.lower() in file_path.lower():
+            results.append(f"📄 File: {file_path}")
+            
+        # Match symbols by name or signature
+        for sym in symbols:
+            if query.lower() in sym["name"].lower() or query.lower() in sym.get("signature", "").lower():
+                sig = sym.get("signature", sym["name"])
+                results.append(f"   🔹 {sig} → {file_path}:{sym['line']}")
+                
+    if results:
+        for r in results:
+            print(r)
+    else:
+        print("   No matches found.")
+
+def show_map():
+    index = load_index()
+    if not index or "files" not in index:
+        print("❌ No index found. Run --action index first.")
+        return
+
+    print("\n🗺️ CODEBASE MAP:")
+    for file_path, symbols in index.get("files", {}).items():
+        print(f"\n📄 {file_path}")
+        for sym in symbols:
+             sig = sym.get("signature", sym["name"])
+             print(f"   L{sym['line']}: {sig}")
+
+
+def show_outline():
+    """Leader-friendly compact outline — one line per file with symbols."""
+    index = load_index()
+    if not index or "files" not in index:
+        print("❌ No index found. Run --action index first.")
+        return
+
+    total_files = len(index["files"])
+    total_symbols = sum(len(s) for s in index["files"].values())
+    print(f"📊 Codebase: {total_files} files, {total_symbols} symbols\n")
+
+    for file_path, symbols in sorted(index.get("files", {}).items()):
+        if not symbols:
+            continue
+        names = [f"{s['name']}:{s['line']}" for s in symbols]
+        print(f"  {file_path} → {', '.join(names)}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Codebase Navigator")
+    parser.add_argument("--action", type=str, required=True, choices=["index", "search", "map", "outline"], help="Action")
+    parser.add_argument("--path", type=str, default=".", help="Root path for indexing")
+    parser.add_argument("--query", type=str, help="Search query")
+    parser.add_argument("--incremental", action="store_true", help="Only update changed files")
+    
+    args = parser.parse_args()
+    
+    if args.action == "index":
+        index_codebase(args.path, args.incremental)
+    elif args.action == "search":
+        if not args.query:
+            print("Error: --query required for search")
+        else:
+            search_index(args.query)
+    elif args.action == "map":
+        show_map()
+    elif args.action == "outline":
+        show_outline()
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/color-palette-generator/SKILL.md

@@ -0,0 +1,26 @@
+---
+name: color-palette-generator
+description: Generates standard Color Palettes for UI design.
+---
+
+# Color Palette Generator
+
+## Purpose
+Provides pre-mixed, UX/UI standard color palettes in various styles (Modern, Corporate, Dark Mode...).
+
+## Usage
+
+### 1. Generate Palette
+```bash
+python .agent/skills/color-palette-generator/scripts/palette.py --style modern
+```
+
+### Supported Styles
+- `modern`: Bright, common for SaaS/Startup (Blue/Green)
+- `corporate`: Formal, trustworthy (Navy/Grey)
+- `playful`: Fun, dynamic (Pink/Purple/Yellow)
+- `dark_tech`: Dark mode, futuristic (Indigo/Neon)
+- `luxury`: Elegant (Gold/Black)
+
+### Output
+Script returns Hex codes and CSS Variables ready-to-copy.

package/assets/.agent/skills/color-palette-generator/data/palettes.json

@@ -0,0 +1,37 @@
+{
+    "modern": {
+        "primary": "#3B82F6",
+        "secondary": "#10B981",
+        "accent": "#F59E0B",
+        "neutral": "#1F2937",
+        "background": "#F3F4F6"
+    },
+    "corporate": {
+        "primary": "#1E40AF",
+        "secondary": "#4B5563",
+        "accent": "#D97706",
+        "neutral": "#111827",
+        "background": "#FFFFFF"
+    },
+    "playful": {
+        "primary": "#EC4899",
+        "secondary": "#8B5CF6",
+        "accent": "#FCD34D",
+        "neutral": "#4B5563",
+        "background": "#FFFBEB"
+    },
+    "dark_tech": {
+        "primary": "#6366F1",
+        "secondary": "#A855F7",
+        "accent": "#10B981",
+        "neutral": "#E5E7EB",
+        "background": "#111827"
+    },
+    "luxury": {
+        "primary": "#D4AF37",
+        "secondary": "#000000",
+        "accent": "#C0C0C0",
+        "neutral": "#333333",
+        "background": "#F5F5F5"
+    }
+}

package/assets/.agent/skills/color-palette-generator/scripts/palette.py

@@ -0,0 +1,57 @@
+#!/usr/bin/env python3
+"""
+Color Palette Generator — Generate harmonious color palettes.
+
+Usage:
+    python palette.py --style modern
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+# Path to data
+DATA_FILE = Path(__file__).parent.parent / "data" / "palettes.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 generate_palette(style):
+    data = load_data()
+    palette = data.get(style.lower())
+    
+    print("\n" + "="*50)
+    print(f"🎨 COLOR PALETTE: {style.upper()}")
+    print("="*50)
+    
+    if not palette:
+        print(f"⚠️  Style '{style}' not found. Available: {', '.join(data.keys())}")
+        return
+
+    print(f"   Primary:   {palette['primary']}  ██████")
+    print(f"   Secondary: {palette['secondary']}  ██████")
+    print(f"   Accent:    {palette['accent']}  ██████")
+    print(f"   Neutral:   {palette['neutral']}  ██████")
+    print(f"   Background:{palette['background']}  ██████")
+    
+    print("\n   CSS Variables:")
+    print("   :root {")
+    for key, value in palette.items():
+        print(f"     --color-{key}: {value};")
+    print("   }")
+    
+    print("="*50 + "\n")
+
+def main():
+    parser = argparse.ArgumentParser(description="Color Palette Generator")
+    parser.add_argument("--style", type=str, default="modern", help="Style: modern, corporate, playful, dark_tech, luxury")
+    
+    args = parser.parse_args()
+    generate_palette(args.style)
+
+if __name__ == "__main__":
+    main()

package/assets/.agent/skills/competitive-landscape/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: competitive-landscape
+description: This skill should be used when the user asks to "analyze
+  competitors", "assess competitive landscape", "identify differentiation",
+  "evaluate market positioning", "apply Porter's Five Forces", or requests
+  competitive strategy analysis.
+metadata:
+  version: 1.0.0
+---
+
+# Competitive Landscape Analysis
+
+Comprehensive frameworks for analyzing competition, identifying differentiation opportunities, and developing winning market positioning strategies.
+
+## Use this skill when
+
+- Working on competitive landscape analysis tasks or workflows
+- Needing guidance, best practices, or checklists for competitive landscape analysis
+
+## Do not use this skill when
+
+- The task is unrelated to competitive landscape analysis
+- 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`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.