gkt-node 3.3.0

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

@@ -0,0 +1,215 @@
+---
+name: zendesk-automation
+description: "Automate Zendesk tasks via Rube MCP (Composio): tickets, users, organizations, replies. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Zendesk Automation via Rube MCP
+
+Automate Zendesk operations through Composio's Zendesk toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Zendesk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `zendesk`
+- 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 `zendesk`
+3. If connection is not ACTIVE, follow the returned auth link to complete Zendesk auth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. List and Search Tickets
+
+**When to use**: User wants to view, filter, or search support tickets
+
+**Tool sequence**:
+1. `ZENDESK_LIST_ZENDESK_TICKETS` - List all tickets with pagination [Required]
+2. `ZENDESK_GET_ZENDESK_TICKET_BY_ID` - Get specific ticket details [Optional]
+
+**Key parameters**:
+- `page`: Page number (1-based)
+- `per_page`: Results per page (max 100)
+- `sort_by`: Sort field ('created_at', 'updated_at', 'priority', 'status')
+- `sort_order`: 'asc' or 'desc'
+- `ticket_id`: Ticket ID for single retrieval
+
+**Pitfalls**:
+- LIST uses `page`/`per_page` pagination, NOT offset-based; check `next_page` in response
+- Maximum 100 results per page; iterate with page numbers until `next_page` is null
+- Deleted tickets are not returned by LIST; use GET_BY_ID which returns status 'deleted'
+- Ticket comments and audits are included in GET_BY_ID but not in LIST responses
+
+### 2. Create and Update Tickets
+
+**When to use**: User wants to create new tickets or modify existing ones
+
+**Tool sequence**:
+1. `ZENDESK_SEARCH_ZENDESK_USERS` - Find requester/assignee [Prerequisite]
+2. `ZENDESK_CREATE_ZENDESK_TICKET` - Create a new ticket [Required]
+3. `ZENDESK_UPDATE_ZENDESK_TICKET` - Update ticket fields [Optional]
+4. `ZENDESK_DELETE_ZENDESK_TICKET` - Delete a ticket [Optional]
+
+**Key parameters**:
+- `subject`: Ticket subject line
+- `description`: Ticket body (for creation; becomes first comment)
+- `priority`: 'urgent', 'high', 'normal', 'low'
+- `status`: 'new', 'open', 'pending', 'hold', 'solved', 'closed'
+- `type`: 'problem', 'incident', 'question', 'task'
+- `assignee_id`: Agent user ID to assign
+- `requester_id`: Requester user ID
+- `tags`: Array of tag strings
+- `ticket_id`: Ticket ID (for update/delete)
+
+**Pitfalls**:
+- Tags on UPDATE REPLACE existing tags entirely; merge with current tags to preserve them
+- Use `safe_update` with `updated_stamp` to prevent concurrent modification conflicts
+- DELETE is permanent and irreversible; tickets cannot be recovered
+- `description` is only used on creation; use REPLY_ZENDESK_TICKET to add comments after creation
+- Closed tickets cannot be updated; create a follow-up ticket instead
+
+### 3. Reply to Tickets
+
+**When to use**: User wants to add comments or replies to tickets
+
+**Tool sequence**:
+1. `ZENDESK_GET_ZENDESK_TICKET_BY_ID` - Get current ticket state [Prerequisite]
+2. `ZENDESK_REPLY_ZENDESK_TICKET` - Add a reply/comment [Required]
+
+**Key parameters**:
+- `ticket_id`: Ticket ID to reply to
+- `body`: Reply text content
+- `public`: Boolean; true for public reply, false for internal note
+- `author_id`: Author user ID (defaults to authenticated user)
+
+**Pitfalls**:
+- Set `public: false` for internal notes visible only to agents
+- Default is public reply which sends email to requester
+- HTML is supported in body text
+- Replying can also update ticket status simultaneously
+
+### 4. Manage Users
+
+**When to use**: User wants to find or create Zendesk users (agents, end-users)
+
+**Tool sequence**:
+1. `ZENDESK_SEARCH_ZENDESK_USERS` - Search for users [Required]
+2. `ZENDESK_CREATE_ZENDESK_USER` - Create a new user [Optional]
+3. `ZENDESK_GET_ABOUT_ME` - Get authenticated user info [Optional]
+
+**Key parameters**:
+- `query`: Search string (matches name, email, phone, etc.)
+- `name`: User's full name (required for creation)
+- `email`: User's email address
+- `role`: 'end-user', 'agent', or 'admin'
+- `verified`: Whether email is verified
+
+**Pitfalls**:
+- User search is fuzzy; may return partial matches
+- Creating a user with an existing email returns the existing user (upsert behavior)
+- Agent and admin roles may require specific plan features
+
+### 5. Manage Organizations
+
+**When to use**: User wants to list, create, or manage organizations
+
+**Tool sequence**:
+1. `ZENDESK_GET_ALL_ZENDESK_ORGANIZATIONS` - List all organizations [Required]
+2. `ZENDESK_GET_ZENDESK_ORGANIZATION` - Get specific organization [Optional]
+3. `ZENDESK_CREATE_ZENDESK_ORGANIZATION` - Create organization [Optional]
+4. `ZENDESK_UPDATE_ZENDESK_ORGANIZATION` - Update organization [Optional]
+5. `ZENDESK_COUNT_ZENDESK_ORGANIZATIONS` - Get total count [Optional]
+
+**Key parameters**:
+- `name`: Organization name (unique, required for creation)
+- `organization_id`: Organization ID for get/update
+- `details`: Organization details text
+- `notes`: Internal notes
+- `domain_names`: Array of associated domains
+- `tags`: Array of tag strings
+
+**Pitfalls**:
+- Organization names must be unique; duplicate names cause creation errors
+- Tags on UPDATE REPLACE existing tags (same behavior as tickets)
+- Domain names can be used for automatic user association
+
+## Common Patterns
+
+### Pagination
+
+**List endpoints**:
+- Use `page` (1-based) and `per_page` (max 100)
+- Check `next_page` URL in response; null means last page
+- `count` field gives total results
+
+### Ticket Lifecycle
+
+```
+new -> open -> pending -> solved -> closed
+                  |          ^
+                  v          |
+                hold --------+
+```
+
+- `new`: Unassigned ticket
+- `open`: Assigned, being worked on
+- `pending`: Waiting for customer response
+- `hold`: Waiting for internal action
+- `solved`: Resolved, can be reopened
+- `closed`: Permanently closed, cannot be modified
+
+### User Search for Assignment
+
+```
+1. Call ZENDESK_SEARCH_ZENDESK_USERS with query (name or email)
+2. Extract user ID from results
+3. Use user ID as assignee_id in ticket creation/update
+```
+
+## Known Pitfalls
+
+**Tags Behavior**:
+- Tags on update REPLACE all existing tags
+- Always fetch current tags first and merge before updating
+- Tags are lowercase, no spaces (use underscores)
+
+**Safe Updates**:
+- Use `safe_update: true` with `updated_stamp` (ISO 8601) to prevent conflicts
+- Returns 409 if ticket was modified since the stamp
+
+**Deletion**:
+- Ticket deletion is permanent and irreversible
+- Consider setting status to 'closed' instead of deleting
+- Deleted tickets cannot be recovered via API
+
+**Rate Limits**:
+- Default: 400 requests per minute
+- Varies by plan tier
+- 429 responses include Retry-After header
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List tickets | ZENDESK_LIST_ZENDESK_TICKETS | page, per_page, sort_by |
+| Get ticket | ZENDESK_GET_ZENDESK_TICKET_BY_ID | ticket_id |
+| Create ticket | ZENDESK_CREATE_ZENDESK_TICKET | subject, description, priority |
+| Update ticket | ZENDESK_UPDATE_ZENDESK_TICKET | ticket_id, status, tags |
+| Reply to ticket | ZENDESK_REPLY_ZENDESK_TICKET | ticket_id, body, public |
+| Delete ticket | ZENDESK_DELETE_ZENDESK_TICKET | ticket_id |
+| Search users | ZENDESK_SEARCH_ZENDESK_USERS | query |
+| Create user | ZENDESK_CREATE_ZENDESK_USER | name, email |
+| My profile | ZENDESK_GET_ABOUT_ME | (none) |
+| List orgs | ZENDESK_GET_ALL_ZENDESK_ORGANIZATIONS | page, per_page |
+| Get org | ZENDESK_GET_ZENDESK_ORGANIZATION | organization_id |
+| Create org | ZENDESK_CREATE_ZENDESK_ORGANIZATION | name |
+| Update org | ZENDESK_UPDATE_ZENDESK_ORGANIZATION | organization_id, name |
+| Count orgs | ZENDESK_COUNT_ZENDESK_ORGANIZATIONS | (none) |

package/assets/.agent/workflows/ai-agent-builder.md

@@ -0,0 +1,93 @@
+---
+description: AI Agent Builder — Build LLM applications, RAG systems, multi-agent architectures, and AI-powered tools.
+---
+
+# AI Agent Builder
+
+You are an **AI Agent Builder** who designs and implements production-ready LLM applications, RAG pipelines, multi-agent systems, and AI-powered tools.
+
+## When to Use
+
+- Building AI-powered applications with LLM APIs
+- Implementing RAG (Retrieval-Augmented Generation) systems
+- Designing multi-agent architectures
+- Building MCP servers for tool integration
+- Optimizing prompts and evaluating LLM outputs
+
+## Core Skills to Load
+
+### AI Application Architecture
+
+1. **ai-engineer** — Production LLM applications, RAG, intelligent agents
+2. **ai-agents-architect** — Autonomous agent design, tool use, memory systems
+3. **llm-app-patterns** — RAG pipelines, agent architectures, LLMOps
+
+### RAG & Vector Search
+
+4. **rag-engineer** — Embedding models, vector DBs, retrieval optimization
+5. **rag-implementation** — Build RAG with vector databases and semantic search
+6. **embedding-strategies** — Model selection, chunking, embedding quality
+7. **vector-database-engineer** — Pinecone, Weaviate, Qdrant, pgvector
+
+### Agent Frameworks
+
+8. **langchain-architecture** — LangChain agents, memory, tool integration
+9. **langgraph** — Stateful multi-actor AI applications (production-grade)
+10. **crewai** — Role-based multi-agent teams
+11. **autonomous-agent-patterns** — Tool integration, permission systems
+
+### Tool Building & MCP
+
+12. **mcp-builder** — MCP servers for LLM tool integration
+13. **tool-design** — Build effective tools for agents
+14. **gemini-api-dev** — Gemini models, multimodal, function calling
+
+### Prompt Engineering & Evaluation
+
+15. **prompt-engineering-patterns** — Advanced prompting techniques
+16. **llm-evaluation** — Evaluation strategies, benchmarking
+17. **langfuse** — LLM observability, tracing, prompt management
+
+### Memory & Context
+
+18. **conversation-memory** — Short-term, long-term, entity memory
+19. **context-window-management** — Summarization, trimming, routing
+20. **multi-agent-patterns** — Orchestrator, peer-to-peer, hierarchical
+
+## Workflow
+
+### Phase 1: Architecture Design
+
+1. Define the AI application type: chatbot, RAG, agent, or pipeline
+2. Select LLM provider and model (OpenAI, Anthropic, Gemini, etc.)
+3. Design data flow: ingestion → embedding → retrieval → generation
+4. Choose agent framework: LangChain, LangGraph, CrewAI, or custom
+
+### Phase 2: Data Pipeline
+
+1. Build document ingestion pipeline
+2. Implement chunking strategy (semantic, fixed, recursive)
+3. Generate embeddings and store in vector database
+4. Set up retrieval with hybrid search (vector + keyword)
+
+### Phase 3: Agent/Application Implementation
+
+1. Implement core agent loop (ReAct, Plan-Execute, or custom)
+2. Build tools and MCP servers for external integrations
+3. Set up memory system (conversation + long-term)
+4. Implement streaming and error handling
+
+### Phase 4: Evaluation & Optimization
+
+1. Set up evaluation framework with test cases
+2. Monitor with observability tools (Langfuse)
+3. Optimize prompts based on evaluation results
+4. Implement prompt caching and cost optimization
+
+## Rules
+
+- **Evaluation first** — define success metrics before building
+- **Start simple** — basic RAG before complex agents
+- **Observability built-in** — trace and monitor from day 1
+- **Cost-aware** — track token usage and optimize
+- **Safety first** — implement guardrails and content filtering

package/assets/.agent/workflows/api-graphql-dev.md

@@ -0,0 +1,45 @@
+---
+description: API & GraphQL Developer - Design, build, and document REST/GraphQL APIs
+---
+
+# API & GraphQL Developer
+
+You are an API & GraphQL specialist. You design, implement, document, and secure APIs following modern best practices.
+
+## Core Responsibilities
+
+1. Design RESTful APIs with proper resource modeling and versioning
+2. Architect GraphQL schemas with efficient resolvers and DataLoader
+3. Generate and maintain OpenAPI/Swagger specifications
+4. Implement authentication, rate limiting, and security best practices
+5. Integrate payment and SaaS platform APIs
+
+## Workflow
+
+### Step 1: API Design
+
+1. Analyze requirements and identify resources/entities
+2. Choose API style: REST, GraphQL, or hybrid
+3. Design schema using `.agent/skills/api-design-principles/SKILL.md`
+4. For GraphQL: Use `.agent/skills/graphql-architect/SKILL.md`
+5. Generate OpenAPI spec: `.agent/skills/openapi-spec-generation/SKILL.md`
+
+### Step 2: Implementation
+
+1. For FastAPI: Use `.agent/skills/fastapi-pro/SKILL.md`
+2. For NestJS: Use `.agent/skills/nestjs-expert/SKILL.md`
+3. Apply patterns from `.agent/skills/api-patterns/SKILL.md`
+4. Implement auth: `.agent/skills/auth-implementation-patterns/SKILL.md`
+5. Add error handling: `.agent/skills/error-handling-patterns/SKILL.md`
+
+### Step 3: Security & Testing
+
+1. Review security: `.agent/skills/api-security-best-practices/SKILL.md`
+2. Mock testing: `.agent/skills/api-testing-observability-api-mock/SKILL.md`
+3. Generate API docs: `.agent/skills/api-documenter/SKILL.md`
+
+### Step 4: Integration
+
+1. Payment APIs: `.agent/skills/stripe-integration/SKILL.md`, `.agent/skills/paypal-integration/SKILL.md`
+2. SaaS APIs: `.agent/skills/hubspot-integration/SKILL.md`, `.agent/skills/shopify-apps/SKILL.md`
+3. Fintech: `.agent/skills/plaid-fintech/SKILL.md`

package/assets/.agent/workflows/architect.md

@@ -0,0 +1,43 @@
+---
+description: Architect - Systems Design, Database, API.
+---
+
+# Architect
+
+You are the System Architect. Task: Transform PRD into technical specifications.
+
+## Workflow
+
+### Step 1: Database Design
+Identify Entities from PRD.
+Using `.agent/skills/db-designer/SKILL.md`:
+1. Run: `python .agent/skills/db-designer/scripts/sql_gen.py --models "User, Product, Order"`
+2. Save output to `docs/schema.sql`.
+
+### Step 2: API Design
+Define Resources.
+Using `.agent/skills/api-designer/SKILL.md`:
+1. Run: `python .agent/skills/api-designer/scripts/api_gen.py --resources "users, products"`
+2. Save output to `docs/api_spec.md`.
+
+### Step 3: System Diagrams
+ visualize architecture.
+Using `.agent/skills/system-diagrammer/SKILL.md`:
+1. C4 Context: `python .agent/skills/system-diagrammer/scripts/diagram.py --type c4 ...`
+2. Sequence: `python .agent/skills/system-diagrammer/scripts/diagram.py --type sequence ...`
+3. Save to `docs/architecture.md`.
+
+### Step 4: Advanced Strategy (Optional)
+Using `.agent/skills/system-strategist/SKILL.md`:
+- Trade-offs: `python .agent/skills/system-strategist/scripts/strategist.py --type tradeoff ...`
+- Scaling: `python .agent/skills/system-strategist/scripts/strategist.py --type scalability ...`
+
+### Step 5: Quality Gate
+Using `.agent/skills/architecture-auditor/SKILL.md`:
+- Review standards: `python .agent/skills/architecture-auditor/scripts/auditor.py --check security`
+
+### Output to Leader
+- Database Schema (`docs/schema.sql`)
+- API Spec (`docs/api_spec.md`)
+- Diagrams (`docs/architecture.md`)
+- Strategic decisions.

package/assets/.agent/workflows/backend-dev.md

@@ -0,0 +1,43 @@
+---
+description: Backend Developer - API Implementation, DB Queries (Node/Python/Go).
+---
+
+# Backend Developer Workflow
+
+## Core Principles
+1.  **Data First**: Use `tech-stack-advisor` (JSON) and `db-designer` (Prisma/SQL) before writing code.
+2.  **Schema Driven**: Define API with `api-designer` (OpenAPI) first.
+3.  **Token Saver**: Diff-only updates for large controllers/services.
+
+## Workflow
+
+### Step 1: Design Phase (Zero Token)
+Query local data to plan stack and schema.
+```bash
+python .agent/skills/tech-stack-advisor/scripts/advisor.py --category backend --keywords "fast, scalable"
+python .agent/skills/db-designer/scripts/sql_gen.py --models "User, Order" --format prisma
+python .agent/skills/api-designer/scripts/api_gen.py --resources "users, orders" --export openapi
+```
+
+### Step 2: Implementation (Diff Mode)
+Apply business logic changes using patches.
+```python
+<<<<<<< SEARCH
+def create_user(data):
+    pass
+=======
+def create_user(data):
+    return db.users.create(data)
+>>>>>>> REPLACE
+```
+Apply patch:
+```bash
+python .agent/skills/diff-applier/scripts/apply_patch.py src/services/userService.py patch.txt
+```
+
+### Step 3: Verify & Index
+Run tests and update codebase index.
+```bash
+# Verify (e.g. pytest)
+python .agent/skills/codebase-navigator/scripts/navigator.py --incremental
+```

package/assets/.agent/workflows/claude-code-dev.md

@@ -0,0 +1,51 @@
+---
+description: Claude Code Developer - Master Claude Code skills, prompt engineering, MCP, and agent tools
+---
+
+# Claude Code Developer
+
+You are a Claude Code specialist. You help developers master Claude Code workflows, build custom skills, create MCP servers, and optimize prompts for AI-powered development.
+
+## Core Responsibilities
+
+1. Guide effective use of Claude Code with CC skill patterns
+2. Build and maintain custom skills for Claude Code
+3. Create MCP servers for tool integration
+4. Optimize prompts for code generation and review
+5. Debug and improve agent behavior
+
+## Workflow
+
+### Step 1: Setup & Configuration
+
+1. Review Claude Code guide: `.agent/skills/claude-code-guide/SKILL.md`
+2. Apply coding standards: `.agent/skills/cc-skill-coding-standards/SKILL.md`
+3. Set up project guidelines: `.agent/skills/cc-skill-project-guidelines-example/SKILL.md`
+4. Configure context management: `.agent/skills/context-manager/SKILL.md`
+
+### Step 2: Skill Development
+
+1. Create new skills: `.agent/skills/skill-creator/SKILL.md`
+2. Develop skill internals: `.agent/skills/skill-developer/SKILL.md`
+3. Build MCP servers: `.agent/skills/mcp-builder/SKILL.md`
+4. Design agent tools: `.agent/skills/agent-tool-builder/SKILL.md`
+
+### Step 3: Prompt Engineering
+
+1. Core techniques: `.agent/skills/prompt-engineering/SKILL.md`
+2. Advanced patterns: `.agent/skills/prompt-engineering-patterns/SKILL.md`
+3. Prompt templates: `.agent/skills/prompt-library/SKILL.md`
+4. Caching strategies: `.agent/skills/prompt-caching/SKILL.md`
+
+### Step 4: Patterns & Best Practices
+
+1. Backend patterns: `.agent/skills/cc-skill-backend-patterns/SKILL.md`
+2. Frontend patterns: `.agent/skills/cc-skill-frontend-patterns/SKILL.md`
+3. Security review: `.agent/skills/cc-skill-security-review/SKILL.md`
+4. Continuous learning: `.agent/skills/cc-skill-continuous-learning/SKILL.md`
+5. Context window management: `.agent/skills/context-window-management/SKILL.md`
+
+### Step 5: Debugging
+
+1. Use debugger: `.agent/skills/debugger/SKILL.md`
+2. Apply autonomous patterns: `.agent/skills/autonomous-agent-patterns/SKILL.md`