gkt-node 3.3.0

package/assets/.agent/skills/architecture-patterns/resources/implementation-playbook.md

@@ -0,0 +1,479 @@
+# Architecture Patterns Implementation Playbook
+
+This file contains detailed patterns, checklists, and code samples referenced by the skill.
+
+## Core Concepts
+
+### 1. Clean Architecture (Uncle Bob)
+
+**Layers (dependency flows inward):**
+
+- **Entities**: Core business models
+- **Use Cases**: Application business rules
+- **Interface Adapters**: Controllers, presenters, gateways
+- **Frameworks & Drivers**: UI, database, external services
+
+**Key Principles:**
+
+- Dependencies point inward
+- Inner layers know nothing about outer layers
+- Business logic independent of frameworks
+- Testable without UI, database, or external services
+
+### 2. Hexagonal Architecture (Ports and Adapters)
+
+**Components:**
+
+- **Domain Core**: Business logic
+- **Ports**: Interfaces defining interactions
+- **Adapters**: Implementations of ports (database, REST, message queue)
+
+**Benefits:**
+
+- Swap implementations easily (mock for testing)
+- Technology-agnostic core
+- Clear separation of concerns
+
+### 3. Domain-Driven Design (DDD)
+
+**Strategic Patterns:**
+
+- **Bounded Contexts**: Separate models for different domains
+- **Context Mapping**: How contexts relate
+- **Ubiquitous Language**: Shared terminology
+
+**Tactical Patterns:**
+
+- **Entities**: Objects with identity
+- **Value Objects**: Immutable objects defined by attributes
+- **Aggregates**: Consistency boundaries
+- **Repositories**: Data access abstraction
+- **Domain Events**: Things that happened
+
+## Clean Architecture Pattern
+
+### Directory Structure
+
+```
+app/
+├── domain/           # Entities & business rules
+│   ├── entities/
+│   │   ├── user.py
+│   │   └── order.py
+│   ├── value_objects/
+│   │   ├── email.py
+│   │   └── money.py
+│   └── interfaces/   # Abstract interfaces
+│       ├── user_repository.py
+│       └── payment_gateway.py
+├── use_cases/        # Application business rules
+│   ├── create_user.py
+│   ├── process_order.py
+│   └── send_notification.py
+├── adapters/         # Interface implementations
+│   ├── repositories/
+│   │   ├── postgres_user_repository.py
+│   │   └── redis_cache_repository.py
+│   ├── controllers/
+│   │   └── user_controller.py
+│   └── gateways/
+│       ├── stripe_payment_gateway.py
+│       └── sendgrid_email_gateway.py
+└── infrastructure/   # Framework & external concerns
+    ├── database.py
+    ├── config.py
+    └── logging.py
+```
+
+### Implementation Example
+
+```python
+# domain/entities/user.py
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+@dataclass
+class User:
+    """Core user entity - no framework dependencies."""
+    id: str
+    email: str
+    name: str
+    created_at: datetime
+    is_active: bool = True
+
+    def deactivate(self):
+        """Business rule: deactivating user."""
+        self.is_active = False
+
+    def can_place_order(self) -> bool:
+        """Business rule: active users can order."""
+        return self.is_active
+
+# domain/interfaces/user_repository.py
+from abc import ABC, abstractmethod
+from typing import Optional, List
+from domain.entities.user import User
+
+class IUserRepository(ABC):
+    """Port: defines contract, no implementation."""
+
+    @abstractmethod
+    async def find_by_id(self, user_id: str) -> Optional[User]:
+        pass
+
+    @abstractmethod
+    async def find_by_email(self, email: str) -> Optional[User]:
+        pass
+
+    @abstractmethod
+    async def save(self, user: User) -> User:
+        pass
+
+    @abstractmethod
+    async def delete(self, user_id: str) -> bool:
+        pass
+
+# use_cases/create_user.py
+from domain.entities.user import User
+from domain.interfaces.user_repository import IUserRepository
+from dataclasses import dataclass
+from datetime import datetime
+import uuid
+
+@dataclass
+class CreateUserRequest:
+    email: str
+    name: str
+
+@dataclass
+class CreateUserResponse:
+    user: User
+    success: bool
+    error: Optional[str] = None
+
+class CreateUserUseCase:
+    """Use case: orchestrates business logic."""
+
+    def __init__(self, user_repository: IUserRepository):
+        self.user_repository = user_repository
+
+    async def execute(self, request: CreateUserRequest) -> CreateUserResponse:
+        # Business validation
+        existing = await self.user_repository.find_by_email(request.email)
+        if existing:
+            return CreateUserResponse(
+                user=None,
+                success=False,
+                error="Email already exists"
+            )
+
+        # Create entity
+        user = User(
+            id=str(uuid.uuid4()),
+            email=request.email,
+            name=request.name,
+            created_at=datetime.now(),
+            is_active=True
+        )
+
+        # Persist
+        saved_user = await self.user_repository.save(user)
+
+        return CreateUserResponse(
+            user=saved_user,
+            success=True
+        )
+
+# adapters/repositories/postgres_user_repository.py
+from domain.interfaces.user_repository import IUserRepository
+from domain.entities.user import User
+from typing import Optional
+import asyncpg
+
+class PostgresUserRepository(IUserRepository):
+    """Adapter: PostgreSQL implementation."""
+
+    def __init__(self, pool: asyncpg.Pool):
+        self.pool = pool
+
+    async def find_by_id(self, user_id: str) -> Optional[User]:
+        async with self.pool.acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT * FROM users WHERE id = $1", user_id
+            )
+            return self._to_entity(row) if row else None
+
+    async def find_by_email(self, email: str) -> Optional[User]:
+        async with self.pool.acquire() as conn:
+            row = await conn.fetchrow(
+                "SELECT * FROM users WHERE email = $1", email
+            )
+            return self._to_entity(row) if row else None
+
+    async def save(self, user: User) -> User:
+        async with self.pool.acquire() as conn:
+            await conn.execute(
+                """
+                INSERT INTO users (id, email, name, created_at, is_active)
+                VALUES ($1, $2, $3, $4, $5)
+                ON CONFLICT (id) DO UPDATE
+                SET email = $2, name = $3, is_active = $5
+                """,
+                user.id, user.email, user.name, user.created_at, user.is_active
+            )
+            return user
+
+    async def delete(self, user_id: str) -> bool:
+        async with self.pool.acquire() as conn:
+            result = await conn.execute(
+                "DELETE FROM users WHERE id = $1", user_id
+            )
+            return result == "DELETE 1"
+
+    def _to_entity(self, row) -> User:
+        """Map database row to entity."""
+        return User(
+            id=row["id"],
+            email=row["email"],
+            name=row["name"],
+            created_at=row["created_at"],
+            is_active=row["is_active"]
+        )
+
+# adapters/controllers/user_controller.py
+from fastapi import APIRouter, Depends, HTTPException
+from use_cases.create_user import CreateUserUseCase, CreateUserRequest
+from pydantic import BaseModel
+
+router = APIRouter()
+
+class CreateUserDTO(BaseModel):
+    email: str
+    name: str
+
+@router.post("/users")
+async def create_user(
+    dto: CreateUserDTO,
+    use_case: CreateUserUseCase = Depends(get_create_user_use_case)
+):
+    """Controller: handles HTTP concerns only."""
+    request = CreateUserRequest(email=dto.email, name=dto.name)
+    response = await use_case.execute(request)
+
+    if not response.success:
+        raise HTTPException(status_code=400, detail=response.error)
+
+    return {"user": response.user}
+```
+
+## Hexagonal Architecture Pattern
+
+```python
+# Core domain (hexagon center)
+class OrderService:
+    """Domain service - no infrastructure dependencies."""
+
+    def __init__(
+        self,
+        order_repository: OrderRepositoryPort,
+        payment_gateway: PaymentGatewayPort,
+        notification_service: NotificationPort
+    ):
+        self.orders = order_repository
+        self.payments = payment_gateway
+        self.notifications = notification_service
+
+    async def place_order(self, order: Order) -> OrderResult:
+        # Business logic
+        if not order.is_valid():
+            return OrderResult(success=False, error="Invalid order")
+
+        # Use ports (interfaces)
+        payment = await self.payments.charge(
+            amount=order.total,
+            customer=order.customer_id
+        )
+
+        if not payment.success:
+            return OrderResult(success=False, error="Payment failed")
+
+        order.mark_as_paid()
+        saved_order = await self.orders.save(order)
+
+        await self.notifications.send(
+            to=order.customer_email,
+            subject="Order confirmed",
+            body=f"Order {order.id} confirmed"
+        )
+
+        return OrderResult(success=True, order=saved_order)
+
+# Ports (interfaces)
+class OrderRepositoryPort(ABC):
+    @abstractmethod
+    async def save(self, order: Order) -> Order:
+        pass
+
+class PaymentGatewayPort(ABC):
+    @abstractmethod
+    async def charge(self, amount: Money, customer: str) -> PaymentResult:
+        pass
+
+class NotificationPort(ABC):
+    @abstractmethod
+    async def send(self, to: str, subject: str, body: str):
+        pass
+
+# Adapters (implementations)
+class StripePaymentAdapter(PaymentGatewayPort):
+    """Primary adapter: connects to Stripe API."""
+
+    def __init__(self, api_key: str):
+        self.stripe = stripe
+        self.stripe.api_key = api_key
+
+    async def charge(self, amount: Money, customer: str) -> PaymentResult:
+        try:
+            charge = self.stripe.Charge.create(
+                amount=amount.cents,
+                currency=amount.currency,
+                customer=customer
+            )
+            return PaymentResult(success=True, transaction_id=charge.id)
+        except stripe.error.CardError as e:
+            return PaymentResult(success=False, error=str(e))
+
+class MockPaymentAdapter(PaymentGatewayPort):
+    """Test adapter: no external dependencies."""
+
+    async def charge(self, amount: Money, customer: str) -> PaymentResult:
+        return PaymentResult(success=True, transaction_id="mock-123")
+```
+
+## Domain-Driven Design Pattern
+
+```python
+# Value Objects (immutable)
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass(frozen=True)
+class Email:
+    """Value object: validated email."""
+    value: str
+
+    def __post_init__(self):
+        if "@" not in self.value:
+            raise ValueError("Invalid email")
+
+@dataclass(frozen=True)
+class Money:
+    """Value object: amount with currency."""
+    amount: int  # cents
+    currency: str
+
+    def add(self, other: "Money") -> "Money":
+        if self.currency != other.currency:
+            raise ValueError("Currency mismatch")
+        return Money(self.amount + other.amount, self.currency)
+
+# Entities (with identity)
+class Order:
+    """Entity: has identity, mutable state."""
+
+    def __init__(self, id: str, customer: Customer):
+        self.id = id
+        self.customer = customer
+        self.items: List[OrderItem] = []
+        self.status = OrderStatus.PENDING
+        self._events: List[DomainEvent] = []
+
+    def add_item(self, product: Product, quantity: int):
+        """Business logic in entity."""
+        item = OrderItem(product, quantity)
+        self.items.append(item)
+        self._events.append(ItemAddedEvent(self.id, item))
+
+    def total(self) -> Money:
+        """Calculated property."""
+        return sum(item.subtotal() for item in self.items)
+
+    def submit(self):
+        """State transition with business rules."""
+        if not self.items:
+            raise ValueError("Cannot submit empty order")
+        if self.status != OrderStatus.PENDING:
+            raise ValueError("Order already submitted")
+
+        self.status = OrderStatus.SUBMITTED
+        self._events.append(OrderSubmittedEvent(self.id))
+
+# Aggregates (consistency boundary)
+class Customer:
+    """Aggregate root: controls access to entities."""
+
+    def __init__(self, id: str, email: Email):
+        self.id = id
+        self.email = email
+        self._addresses: List[Address] = []
+        self._orders: List[str] = []  # Order IDs, not full objects
+
+    def add_address(self, address: Address):
+        """Aggregate enforces invariants."""
+        if len(self._addresses) >= 5:
+            raise ValueError("Maximum 5 addresses allowed")
+        self._addresses.append(address)
+
+    @property
+    def primary_address(self) -> Optional[Address]:
+        return next((a for a in self._addresses if a.is_primary), None)
+
+# Domain Events
+@dataclass
+class OrderSubmittedEvent:
+    order_id: str
+    occurred_at: datetime = field(default_factory=datetime.now)
+
+# Repository (aggregate persistence)
+class OrderRepository:
+    """Repository: persist/retrieve aggregates."""
+
+    async def find_by_id(self, order_id: str) -> Optional[Order]:
+        """Reconstitute aggregate from storage."""
+        pass
+
+    async def save(self, order: Order):
+        """Persist aggregate and publish events."""
+        await self._persist(order)
+        await self._publish_events(order._events)
+        order._events.clear()
+```
+
+## Resources
+
+- **references/clean-architecture-guide.md**: Detailed layer breakdown
+- **references/hexagonal-architecture-guide.md**: Ports and adapters patterns
+- **references/ddd-tactical-patterns.md**: Entities, value objects, aggregates
+- **assets/clean-architecture-template/**: Complete project structure
+- **assets/ddd-examples/**: Domain modeling examples
+
+## Best Practices
+
+1. **Dependency Rule**: Dependencies always point inward
+2. **Interface Segregation**: Small, focused interfaces
+3. **Business Logic in Domain**: Keep frameworks out of core
+4. **Test Independence**: Core testable without infrastructure
+5. **Bounded Contexts**: Clear domain boundaries
+6. **Ubiquitous Language**: Consistent terminology
+7. **Thin Controllers**: Delegate to use cases
+8. **Rich Domain Models**: Behavior with data
+
+## Common Pitfalls
+
+- **Anemic Domain**: Entities with only data, no behavior
+- **Framework Coupling**: Business logic depends on frameworks
+- **Fat Controllers**: Business logic in controllers
+- **Repository Leakage**: Exposing ORM objects
+- **Missing Abstractions**: Concrete dependencies in core
+- **Over-Engineering**: Clean architecture for simple CRUD

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

@@ -0,0 +1,171 @@
+---
+name: asana-automation
+description: "Automate Asana tasks via Rube MCP (Composio): tasks, projects, sections, teams, workspaces. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Asana Automation via Rube MCP
+
+Automate Asana operations through Composio's Asana toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Asana connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `asana`
+- 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 `asana`
+3. If connection is not ACTIVE, follow the returned auth link to complete Asana OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Manage Tasks
+
+**When to use**: User wants to create, search, list, or organize tasks
+
+**Tool sequence**:
+1. `ASANA_GET_MULTIPLE_WORKSPACES` - Get workspace ID [Prerequisite]
+2. `ASANA_SEARCH_TASKS_IN_WORKSPACE` - Search tasks [Optional]
+3. `ASANA_GET_TASKS_FROM_A_PROJECT` - List project tasks [Optional]
+4. `ASANA_CREATE_A_TASK` - Create a new task [Optional]
+5. `ASANA_GET_A_TASK` - Get task details [Optional]
+6. `ASANA_CREATE_SUBTASK` - Create a subtask [Optional]
+7. `ASANA_GET_TASK_SUBTASKS` - List subtasks [Optional]
+
+**Key parameters**:
+- `workspace`: Workspace GID (required for search/creation)
+- `projects`: Array of project GIDs to add task to
+- `name`: Task name
+- `notes`: Task description
+- `assignee`: Assignee (user GID or email)
+- `due_on`: Due date (YYYY-MM-DD)
+
+**Pitfalls**:
+- Workspace GID is required for most operations; get it first
+- Task GIDs are returned as strings, not integers
+- Search is workspace-scoped, not project-scoped
+
+### 2. Manage Projects and Sections
+
+**When to use**: User wants to create projects, manage sections, or organize tasks
+
+**Tool sequence**:
+1. `ASANA_GET_WORKSPACE_PROJECTS` - List workspace projects [Optional]
+2. `ASANA_GET_A_PROJECT` - Get project details [Optional]
+3. `ASANA_CREATE_A_PROJECT` - Create a new project [Optional]
+4. `ASANA_GET_SECTIONS_IN_PROJECT` - List sections [Optional]
+5. `ASANA_CREATE_SECTION_IN_PROJECT` - Create a new section [Optional]
+6. `ASANA_ADD_TASK_TO_SECTION` - Move task to section [Optional]
+7. `ASANA_GET_TASKS_FROM_A_SECTION` - List tasks in section [Optional]
+
+**Key parameters**:
+- `project_gid`: Project GID
+- `name`: Project or section name
+- `workspace`: Workspace GID for creation
+- `task`: Task GID for section assignment
+- `section`: Section GID
+
+**Pitfalls**:
+- Projects belong to workspaces; workspace GID is needed for creation
+- Sections are ordered within a project
+- DUPLICATE_PROJECT creates a copy with optional task inclusion
+
+### 3. Manage Teams and Users
+
+**When to use**: User wants to list teams, team members, or workspace users
+
+**Tool sequence**:
+1. `ASANA_GET_TEAMS_IN_WORKSPACE` - List workspace teams [Optional]
+2. `ASANA_GET_USERS_FOR_TEAM` - List team members [Optional]
+3. `ASANA_GET_USERS_FOR_WORKSPACE` - List all workspace users [Optional]
+4. `ASANA_GET_CURRENT_USER` - Get authenticated user [Optional]
+5. `ASANA_GET_MULTIPLE_USERS` - Get multiple user details [Optional]
+
+**Key parameters**:
+- `workspace_gid`: Workspace GID
+- `team_gid`: Team GID
+
+**Pitfalls**:
+- Users are workspace-scoped
+- Team membership requires the team GID
+
+### 4. Parallel Operations
+
+**When to use**: User needs to perform bulk operations efficiently
+
+**Tool sequence**:
+1. `ASANA_SUBMIT_PARALLEL_REQUESTS` - Execute multiple API calls in parallel [Required]
+
+**Key parameters**:
+- `actions`: Array of action objects with method, path, and data
+
+**Pitfalls**:
+- Each action must be a valid Asana API call
+- Failed individual requests do not roll back successful ones
+
+## Common Patterns
+
+### ID Resolution
+
+**Workspace name -> GID**:
+```
+1. Call ASANA_GET_MULTIPLE_WORKSPACES
+2. Find workspace by name
+3. Extract gid field
+```
+
+**Project name -> GID**:
+```
+1. Call ASANA_GET_WORKSPACE_PROJECTS with workspace GID
+2. Find project by name
+3. Extract gid field
+```
+
+### Pagination
+
+- Asana uses cursor-based pagination with `offset` parameter
+- Check for `next_page` in response
+- Pass `offset` from `next_page.offset` for next request
+
+## Known Pitfalls
+
+**GID Format**:
+- All Asana IDs are strings (GIDs), not integers
+- GIDs are globally unique identifiers
+
+**Workspace Scoping**:
+- Most operations require a workspace context
+- Tasks, projects, and users are workspace-scoped
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List workspaces | ASANA_GET_MULTIPLE_WORKSPACES | (none) |
+| Search tasks | ASANA_SEARCH_TASKS_IN_WORKSPACE | workspace, text |
+| Create task | ASANA_CREATE_A_TASK | workspace, name, projects |
+| Get task | ASANA_GET_A_TASK | task_gid |
+| Create subtask | ASANA_CREATE_SUBTASK | parent, name |
+| List subtasks | ASANA_GET_TASK_SUBTASKS | task_gid |
+| Project tasks | ASANA_GET_TASKS_FROM_A_PROJECT | project_gid |
+| List projects | ASANA_GET_WORKSPACE_PROJECTS | workspace |
+| Create project | ASANA_CREATE_A_PROJECT | workspace, name |
+| Get project | ASANA_GET_A_PROJECT | project_gid |
+| Duplicate project | ASANA_DUPLICATE_PROJECT | project_gid |
+| List sections | ASANA_GET_SECTIONS_IN_PROJECT | project_gid |
+| Create section | ASANA_CREATE_SECTION_IN_PROJECT | project_gid, name |
+| Add to section | ASANA_ADD_TASK_TO_SECTION | section, task |
+| Section tasks | ASANA_GET_TASKS_FROM_A_SECTION | section_gid |
+| List teams | ASANA_GET_TEAMS_IN_WORKSPACE | workspace_gid |
+| Team members | ASANA_GET_USERS_FOR_TEAM | team_gid |
+| Workspace users | ASANA_GET_USERS_FOR_WORKSPACE | workspace_gid |
+| Current user | ASANA_GET_CURRENT_USER | (none) |
+| Parallel requests | ASANA_SUBMIT_PARALLEL_REQUESTS | actions |

package/assets/.agent/skills/attack-tree-construction/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: attack-tree-construction
+description: Build comprehensive attack trees to visualize threat paths. Use when mapping attack scenarios, identifying defense gaps, or communicating security risks to stakeholders.
+---
+
+# Attack Tree Construction
+
+Systematic attack path visualization and analysis.
+
+## Use this skill when
+
+- Visualizing complex attack scenarios
+- Identifying defense gaps and priorities
+- Communicating risks to stakeholders
+- Planning defensive investments or test scopes
+
+## Do not use this skill when
+
+- You lack authorization or a defined scope to model the system
+- The task is a general risk review without attack-path modeling
+- The request is unrelated to security assessment or design
+
+## Instructions
+
+- Confirm scope, assets, and the attacker goal for the root node.
+- Decompose into sub-goals with AND/OR structure.
+- Annotate leaves with cost, skill, time, and detectability.
+- Map mitigations per branch and prioritize high-impact paths.
+- If detailed templates are required, open `resources/implementation-playbook.md`.
+
+## Safety
+
+- Share attack trees only with authorized stakeholders.
+- Avoid including sensitive exploit details unless required.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns, templates, and examples.