gkt-node 3.3.0

package/assets/.agent/skills/ui-ux-pro-max/scripts/search.py

@@ -0,0 +1,162 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+UI/UX Pro Max Search - BM25 search engine for UI/UX style guides
+Usage: python search.py "<query>" [--domain <domain>] [--stack <stack>] [--max-results 3]
+       python search.py "<query>" --design-system [-p "Project Name"]
+       python search.py "<query>" --design-system --persist [-p "Project Name"] [--page "dashboard"]
+
+Domains: style, prompt, color, chart, landing, product, ux, typography
+Stacks: html-tailwind, react, nextjs
+
+Persistence (Master + Overrides pattern):
+  --persist    Save design system to design-system/MASTER.md
+  --page       Also create a page-specific override file in design-system/pages/
+"""
+
+import argparse
+import sys
+import io
+import os
+from core import CSV_CONFIG, AVAILABLE_STACKS, MAX_RESULTS, search, search_stack
+from design_system import generate_design_system, persist_design_system
+
+# Force UTF-8 for stdout/stderr to handle emojis on Windows (cp1252 default)
+if sys.stdout.encoding and sys.stdout.encoding.lower() != 'utf-8':
+    sys.stdout = io.TextIOWrapper(sys.stdout.buffer, encoding='utf-8')
+if sys.stderr.encoding and sys.stderr.encoding.lower() != 'utf-8':
+    sys.stderr = io.TextIOWrapper(sys.stderr.buffer, encoding='utf-8')
+
+
+def format_output(result):
+    """Format results for Claude consumption (token-optimized)"""
+    if "error" in result:
+        return f"Error: {result['error']}"
+
+    output = []
+    if result.get("stack"):
+        output.append(f"## UI Pro Max Stack Guidelines")
+        output.append(f"**Stack:** {result['stack']} | **Query:** {result['query']}")
+    else:
+        output.append(f"## UI Pro Max Search Results")
+        output.append(f"**Domain:** {result['domain']} | **Query:** {result['query']}")
+    output.append(f"**Source:** {result['file']} | **Found:** {result['count']} results\n")
+
+    for i, row in enumerate(result['results'], 1):
+        output.append(f"### Result {i}")
+        for key, value in row.items():
+            value_str = str(value)
+            if len(value_str) > 300:
+                value_str = value_str[:300] + "..."
+            output.append(f"- **{key}:** {value_str}")
+        output.append("")
+
+    return "\n".join(output)
+
+
+
+CONTEXT_FILE = ".agent/project_context.json"
+
+def save_context(args):
+    """Save current arguments to context file."""
+    import json
+    context = {}
+    if args.project_name: context["project_name"] = args.project_name
+    if args.query: context["last_query"] = args.query
+    
+    with open(CONTEXT_FILE, "w", encoding="utf-8") as f:
+        json.dump(context, f, indent=2)
+    print(f"💾 Context saved to {CONTEXT_FILE}")
+
+def load_context():
+    """Load arguments from context file."""
+    import json
+    if not os.path.exists(CONTEXT_FILE):
+        return {}
+    try:
+        with open(CONTEXT_FILE, "r", encoding="utf-8") as f:
+            return json.load(f)
+    except:
+        return {}
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="UI Pro Max Search")
+    parser.add_argument("query", nargs="?", help="Search query")
+    parser.add_argument("--domain", "-d", choices=list(CSV_CONFIG.keys()), help="Search domain")
+    parser.add_argument("--stack", "-s", choices=AVAILABLE_STACKS, help="Stack-specific search")
+    parser.add_argument("--max-results", "-n", type=int, default=MAX_RESULTS, help="Max results")
+    parser.add_argument("--json", action="store_true", help="Output as JSON")
+    
+    # Design system
+    parser.add_argument("--design-system", "-ds", action="store_true", help="Generate design system")
+    parser.add_argument("--project-name", "-p", type=str, default=None, help="Project name")
+    parser.add_argument("--format", "-f", choices=["ascii", "markdown"], default="ascii", help="Output format")
+    
+    # Persistence
+    parser.add_argument("--persist", action="store_true", help="Save to design-system/MASTER.md")
+    parser.add_argument("--page", type=str, default=None, help="Page override")
+    parser.add_argument("--output-dir", "-o", type=str, default=None, help="Output directory")
+    
+    # Context
+    parser.add_argument("--save-context", action="store_true", help="Save args to project context")
+    parser.add_argument("--load-context", action="store_true", help="Load args from project context")
+
+    args = parser.parse_args()
+
+    # Load context if requested
+    if args.load_context:
+        context = load_context()
+        if not args.project_name and "project_name" in context:
+            args.project_name = context["project_name"]
+            print(f"📂 Loaded project: {args.project_name}")
+        if not args.query and "last_query" in context:
+            args.query = context["last_query"]
+            print(f"🔎 Loaded query: {args.query}")
+
+    if not args.query:
+        print("Error: query required (or use --load-context)")
+        sys.exit(1)
+
+    # Save context if requested
+    if args.save_context:
+        save_context(args)
+
+    # Design system takes priority
+    if args.design_system:
+        result = generate_design_system(
+            args.query, 
+            args.project_name, 
+            args.format,
+            persist=args.persist,
+            page=args.page,
+            output_dir=args.output_dir
+        )
+        print(result)
+        
+        if args.persist:
+            project_slug = args.project_name.lower().replace(' ', '-') if args.project_name else "default"
+            print("\n" + "=" * 60)
+            print(f"✅ Design system persisted to design-system/{project_slug}/")
+            print(f"   📄 MASTERT.md")
+            print(f"   🎨 tailwind.config.js (Auto-generated)")
+            if args.page:
+                print(f"   📄 pages/{args.page}.md")
+            print("=" * 60)
+
+    # Stack search
+    elif args.stack:
+        result = search_stack(args.query, args.stack, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))
+    # Domain search
+    else:
+        result = search(args.query, args.domain, args.max_results)
+        if args.json:
+            import json
+            print(json.dumps(result, indent=2, ensure_ascii=False))
+        else:
+            print(format_output(result))
+

package/assets/.agent/skills/using-neon/SKILL.md

@@ -0,0 +1,84 @@
+---
+name: using-neon
+description: "Guides and best practices for working with Neon Serverless Postgres. Covers getting started, local development with Neon, choosing a connection method, Neon features, authentication (@neondatabase/auth), PostgREST-style data API (@neondatabase/neon-js), Neon CLI, and Neon's Platform API/SDKs. Use for any Neon-related questions."
+source: "https://github.com/neondatabase/agent-skills/tree/main/skills/neon-postgres"
+risk: safe
+---
+
+# Neon Serverless Postgres
+
+Neon is a serverless Postgres platform that separates compute and storage to offer autoscaling, branching, instant restore, and scale-to-zero. It's fully compatible with Postgres and works with any language, framework, or ORM that supports Postgres.
+
+## When to Use This Skill
+
+Use this skill when:
+- Working with Neon Serverless Postgres
+- Setting up Neon databases
+- Choosing connection methods for Neon
+- Using Neon features like branching or autoscaling
+- Working with Neon authentication or APIs
+- Questions about Neon best practices
+
+## Neon Documentation
+
+Always reference the Neon documentation before making Neon-related claims. The documentation is the source of truth for all Neon-related information.
+
+Below you'll find a list of resources organized by area of concern. This is meant to support you find the right documentation pages to fetch and add a bit of additonal context.
+
+You can use the `curl` commands to fetch the documentation page as markdown:
+
+**Documentation:**
+
+```bash
+# Get list of all Neon docs
+curl https://neon.com/llms.txt
+
+# Fetch any doc page as markdown
+curl -H "Accept: text/markdown" https://neon.com/docs/<path>
+```
+
+Don't guess docs pages. Use the `llms.txt` index to find the relevant URL or follow the links in the resources below.
+
+## Overview of Resources
+
+Reference the appropriate resource file based on the user's needs:
+
+### Core Guides
+
+| Area               | Resource                           | When to Use                                                    |
+| ------------------ | ---------------------------------- | -------------------------------------------------------------- |
+| What is Neon       | `references/what-is-neon.md`       | Understanding Neon concepts, architecture, core resources      |
+| Referencing Docs   | `references/referencing-docs.md`   | Looking up official documentation, verifying information       |
+| Features           | `references/features.md`           | Branching, autoscaling, scale-to-zero, instant restore         |
+| Getting Started    | `references/getting-started.md`    | Setting up a project, connection strings, dependencies, schema |
+| Connection Methods | `references/connection-methods.md` | Choosing drivers based on platform and runtime                 |
+| Developer Tools    | `references/devtools.md`           | VSCode extension, MCP server, Neon CLI (`neon init`)           |
+
+### Database Drivers & ORMs
+
+HTTP/WebSocket queries for serverless/edge functions.
+
+| Area              | Resource                        | When to Use                                         |
+| ----------------- | ------------------------------- | --------------------------------------------------- |
+| Serverless Driver | `references/neon-serverless.md` | `@neondatabase/serverless` - HTTP/WebSocket queries |
+| Drizzle ORM       | `references/neon-drizzle.md`    | Drizzle ORM integration with Neon                   |
+
+### Auth & Data API SDKs
+
+Authentication and PostgREST-style data API for Neon.
+
+| Area        | Resource                  | When to Use                                                         |
+| ----------- | ------------------------- | ------------------------------------------------------------------- |
+| Neon Auth   | `references/neon-auth.md` | `@neondatabase/auth` - Authentication only                          |
+| Neon JS SDK | `references/neon-js.md`   | `@neondatabase/neon-js` - Auth + Data API (PostgREST-style queries) |
+
+### Neon Platform API & CLI
+
+Managing Neon resources programmatically via REST API, SDKs, or CLI.
+
+| Area                  | Resource                            | When to Use                                  |
+| --------------------- | ----------------------------------- | -------------------------------------------- |
+| Platform API Overview | `references/neon-platform-api.md`   | Managing Neon resources via REST API         |
+| Neon CLI              | `references/neon-cli.md`            | Terminal workflows, scripts, CI/CD pipelines |
+| TypeScript SDK        | `references/neon-typescript-sdk.md` | `@neondatabase/api-client`                   |
+| Python SDK            | `references/neon-python-sdk.md`     | `neon-api` package                           |

package/assets/.agent/skills/vector-database-engineer/SKILL.md

@@ -0,0 +1,60 @@
+---
+name: vector-database-engineer
+description: "Expert in vector databases, embedding strategies, and semantic search implementation. Masters Pinecone, Weaviate, Qdrant, Milvus, and pgvector for RAG applications, recommendation systems, and similar"
+---
+
+# Vector Database Engineer
+
+Expert in vector databases, embedding strategies, and semantic search implementation. Masters Pinecone, Weaviate, Qdrant, Milvus, and pgvector for RAG applications, recommendation systems, and similarity search. Use PROACTIVELY for vector search implementation, embedding optimization, or semantic retrieval systems.
+
+## Do not use this skill when
+
+- The task is unrelated to vector database engineer
+- 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`.
+
+## Capabilities
+
+- Vector database selection and architecture
+- Embedding model selection and optimization
+- Index configuration (HNSW, IVF, PQ)
+- Hybrid search (vector + keyword) implementation
+- Chunking strategies for documents
+- Metadata filtering and pre/post-filtering
+- Performance tuning and scaling
+
+## Use this skill when
+
+- Building RAG (Retrieval Augmented Generation) systems
+- Implementing semantic search over documents
+- Creating recommendation engines
+- Building image/audio similarity search
+- Optimizing vector search latency and recall
+- Scaling vector operations to millions of vectors
+
+## Workflow
+
+1. Analyze data characteristics and query patterns
+2. Select appropriate embedding model
+3. Design chunking and preprocessing pipeline
+4. Choose vector database and index type
+5. Configure metadata schema for filtering
+6. Implement hybrid search if needed
+7. Optimize for latency/recall tradeoffs
+8. Set up monitoring and reindexing strategies
+
+## Best Practices
+
+- Choose embedding dimensions based on use case (384-1536)
+- Implement proper chunking with overlap
+- Use metadata filtering to reduce search space
+- Monitor embedding drift over time
+- Plan for index rebuilding
+- Cache frequent queries
+- Test recall vs latency tradeoffs

package/assets/.agent/skills/vector-index-tuning/SKILL.md

@@ -0,0 +1,42 @@
+---
+name: vector-index-tuning
+description: Optimize vector index performance for latency, recall, and memory. Use when tuning HNSW parameters, selecting quantization strategies, or scaling vector search infrastructure.
+---
+
+# Vector Index Tuning
+
+Guide to optimizing vector indexes for production performance.
+
+## Use this skill when
+
+- Tuning HNSW parameters
+- Implementing quantization
+- Optimizing memory usage
+- Reducing search latency
+- Balancing recall vs speed
+- Scaling to billions of vectors
+
+## Do not use this skill when
+
+- You only need exact search on small datasets (use a flat index)
+- You lack workload metrics or ground truth to validate recall
+- You need end-to-end retrieval system design beyond index tuning
+
+## Instructions
+
+1. Gather workload targets (latency, recall, QPS), data size, and memory budget.
+2. Choose an index type and establish a baseline with default parameters.
+3. Benchmark parameter sweeps using real queries and track recall, latency, and memory.
+4. Validate changes on a staging dataset before rolling out to production.
+
+Refer to `resources/implementation-playbook.md` for detailed patterns, checklists, and templates.
+
+## Safety
+
+- Avoid reindexing in production without a rollback plan.
+- Validate changes under realistic load before applying globally.
+- Track recall regressions and revert if quality drops.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns, checklists, and templates.