skill-library-mcp 1.0.0

package/skills/c4-component/SKILL.md

@@ -0,0 +1,153 @@
+---
+name: c4-component
+description: Expert C4 Component-level documentation specialist. Synthesizes C4
+  Code-level documentation into Component-level architecture, defining component
+  boundaries, interfaces, and relationships. Creates component diagrams and
+  documentation. Use when synthesizing code-level documentation into logical
+  components.
+metadata:
+  model: sonnet
+---
+
+# C4 Component Level: [Component Name]
+
+## Use this skill when
+
+- Working on c4 component level: [component name] tasks or workflows
+- Needing guidance, best practices, or checklists for c4 component level: [component name]
+
+## Do not use this skill when
+
+- The task is unrelated to c4 component level: [component name]
+- 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`.
+
+## Overview
+
+- **Name**: [Component name]
+- **Description**: [Short description of component purpose]
+- **Type**: [Component type: Application, Service, Library, etc.]
+- **Technology**: [Primary technologies used]
+
+## Purpose
+
+[Detailed description of what this component does and what problems it solves]
+
+## Software Features
+
+- [Feature 1]: [Description]
+- [Feature 2]: [Description]
+- [Feature 3]: [Description]
+
+## Code Elements
+
+This component contains the following code-level elements:
+
+- [c4-code-file-1.md](./c4-code-file-1.md) - [Description]
+- [c4-code-file-2.md](./c4-code-file-2.md) - [Description]
+
+## Interfaces
+
+### [Interface Name]
+
+- **Protocol**: [REST/GraphQL/gRPC/Events/etc.]
+- **Description**: [What this interface provides]
+- **Operations**:
+  - `operationName(params): ReturnType` - [Description]
+
+## Dependencies
+
+### Components Used
+
+- [Component Name]: [How it's used]
+
+### External Systems
+
+- [External System]: [How it's used]
+
+## Component Diagram
+
+Use proper Mermaid C4Component syntax. Component diagrams show components **within a single container**:
+
+```mermaid
+C4Component
+    title Component Diagram for [Container Name]
+
+    Container_Boundary(container, "Container Name") {
+        Component(component1, "Component 1", "Type", "Description")
+        Component(component2, "Component 2", "Type", "Description")
+        ComponentDb(component3, "Component 3", "Database", "Description")
+    }
+    Container_Ext(externalContainer, "External Container", "Description")
+    System_Ext(externalSystem, "External System", "Description")
+
+    Rel(component1, component2, "Uses")
+    Rel(component2, component3, "Reads from and writes to")
+    Rel(component1, externalContainer, "Uses", "API")
+    Rel(component2, externalSystem, "Uses", "API")
+```
+````
+
+**Key Principles** (from [c4model.com](https://c4model.com/diagrams/component)):
+
+- Show components **within a single container** (zoom into one container)
+- Focus on **logical components** and their responsibilities
+- Show **component interfaces** (what they expose)
+- Show how components **interact** with each other
+- Include **external dependencies** (other containers, external systems)
+
+````
+
+## Master Component Index Template
+
+```markdown
+# C4 Component Level: System Overview
+
+## System Components
+
+### [Component 1]
+- **Name**: [Component name]
+- **Description**: [Short description]
+- **Documentation**: [c4-component-name-1.md](./c4-component-name-1.md)
+
+### [Component 2]
+- **Name**: [Component name]
+- **Description**: [Short description]
+- **Documentation**: [c4-component-name-2.md](./c4-component-name-2.md)
+
+## Component Relationships
+[Mermaid diagram showing all components and their relationships]
+````
+
+## Example Interactions
+
+- "Synthesize all c4-code-\*.md files into logical components"
+- "Define component boundaries for the authentication and authorization code"
+- "Create component-level documentation for the API layer"
+- "Identify component interfaces and create component diagrams"
+- "Group database access code into components and document their relationships"
+
+## Key Distinctions
+
+- **vs C4-Code agent**: Synthesizes multiple code files into components; Code agent documents individual code elements
+- **vs C4-Container agent**: Focuses on logical grouping; Container agent maps components to deployment units
+- **vs C4-Context agent**: Provides component-level detail; Context agent creates high-level system diagrams
+
+## Output Examples
+
+When synthesizing components, provide:
+
+- Clear component boundaries with rationale
+- Descriptive component names and purposes
+- Comprehensive feature lists for each component
+- Complete interface documentation with protocols and operations
+- Links to all contained c4-code-\*.md files
+- Mermaid component diagrams showing relationships
+- Master component index with all components
+- Consistent documentation format across all components

package/skills/c4-container/SKILL.md

@@ -0,0 +1,171 @@
+---
+name: c4-container
+description: Expert C4 Container-level documentation specialist. Synthesizes
+  Component-level documentation into Container-level architecture, mapping
+  components to deployment units, documenting container interfaces as APIs, and
+  creating container diagrams. Use when synthesizing components into deployment
+  containers and documenting system deployment architecture.
+metadata:
+  model: sonnet
+---
+
+# C4 Container Level: System Deployment
+
+## Use this skill when
+
+- Working on c4 container level: system deployment tasks or workflows
+- Needing guidance, best practices, or checklists for c4 container level: system deployment
+
+## Do not use this skill when
+
+- The task is unrelated to c4 container level: system deployment
+- 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`.
+
+## Containers
+
+### [Container Name]
+
+- **Name**: [Container name]
+- **Description**: [Short description of container purpose and deployment]
+- **Type**: [Web Application, API, Database, Message Queue, etc.]
+- **Technology**: [Primary technologies: Node.js, Python, PostgreSQL, Redis, etc.]
+- **Deployment**: [Docker, Kubernetes, Cloud Service, etc.]
+
+## Purpose
+
+[Detailed description of what this container does and how it's deployed]
+
+## Components
+
+This container deploys the following components:
+
+- [Component Name]: [Description]
+  - Documentation: [c4-component-name.md](./c4-component-name.md)
+
+## Interfaces
+
+### [API/Interface Name]
+
+- **Protocol**: [REST/GraphQL/gRPC/Events/etc.]
+- **Description**: [What this interface provides]
+- **Specification**: [Link to OpenAPI/Swagger/API Spec file]
+- **Endpoints**:
+  - `GET /api/resource` - [Description]
+  - `POST /api/resource` - [Description]
+
+## Dependencies
+
+### Containers Used
+
+- [Container Name]: [How it's used, communication protocol]
+
+### External Systems
+
+- [External System]: [How it's used, integration type]
+
+## Infrastructure
+
+- **Deployment Config**: [Link to Dockerfile, K8s manifest, etc.]
+- **Scaling**: [Horizontal/vertical scaling strategy]
+- **Resources**: [CPU, memory, storage requirements]
+
+## Container Diagram
+
+Use proper Mermaid C4Container syntax:
+
+```mermaid
+C4Container
+    title Container Diagram for [System Name]
+
+    Person(user, "User", "Uses the system")
+    System_Boundary(system, "System Name") {
+        Container(webApp, "Web Application", "Spring Boot, Java", "Provides web interface")
+        Container(api, "API Application", "Node.js, Express", "Provides REST API")
+        ContainerDb(database, "Database", "PostgreSQL", "Stores data")
+        Container_Queue(messageQueue, "Message Queue", "RabbitMQ", "Handles async messaging")
+    }
+    System_Ext(external, "External System", "Third-party service")
+
+    Rel(user, webApp, "Uses", "HTTPS")
+    Rel(webApp, api, "Makes API calls to", "JSON/HTTPS")
+    Rel(api, database, "Reads from and writes to", "SQL")
+    Rel(api, messageQueue, "Publishes messages to")
+    Rel(api, external, "Uses", "API")
+```
+````
+
+**Key Principles** (from [c4model.com](https://c4model.com/diagrams/container)):
+
+- Show **high-level technology choices** (this is where technology details belong)
+- Show how **responsibilities are distributed** across containers
+- Include **container types**: Applications, Databases, Message Queues, File Systems, etc.
+- Show **communication protocols** between containers
+- Include **external systems** that containers interact with
+
+````
+
+## API Specification Template
+
+For each container API, create an OpenAPI/Swagger specification:
+
+```yaml
+openapi: 3.1.0
+info:
+  title: [Container Name] API
+  description: [API description]
+  version: 1.0.0
+servers:
+  - url: https://api.example.com
+    description: Production server
+paths:
+  /api/resource:
+    get:
+      summary: [Operation summary]
+      description: [Operation description]
+      parameters:
+        - name: param1
+          in: query
+          schema:
+            type: string
+      responses:
+        '200':
+          description: [Response description]
+          content:
+            application/json:
+              schema:
+                type: object
+````
+
+## Example Interactions
+
+- "Synthesize all components into containers based on deployment definitions"
+- "Map the API components to containers and document their APIs as OpenAPI specs"
+- "Create container-level documentation for the microservices architecture"
+- "Document container interfaces as Swagger/OpenAPI specifications"
+- "Analyze Kubernetes manifests and create container documentation"
+
+## Key Distinctions
+
+- **vs C4-Component agent**: Maps components to deployment units; Component agent focuses on logical grouping
+- **vs C4-Context agent**: Provides container-level detail; Context agent creates high-level system diagrams
+- **vs C4-Code agent**: Focuses on deployment architecture; Code agent documents individual code elements
+
+## Output Examples
+
+When synthesizing containers, provide:
+
+- Clear container boundaries with deployment rationale
+- Descriptive container names and deployment characteristics
+- Complete API documentation with OpenAPI/Swagger specifications
+- Links to all contained components
+- Mermaid container diagrams showing deployment architecture
+- Links to deployment configurations (Dockerfiles, K8s manifests, etc.)
+- Infrastructure requirements and scaling considerations
+- Consistent documentation format across all containers

package/skills/c4-context/SKILL.md

@@ -0,0 +1,150 @@
+---
+name: c4-context
+description: Expert C4 Context-level documentation specialist. Creates
+  high-level system context diagrams, documents personas, user journeys, system
+  features, and external dependencies. Synthesizes container and component
+  documentation with system documentation to create comprehensive context-level
+  architecture. Use when creating the highest-level C4 system context
+  documentation.
+metadata:
+  model: sonnet
+---
+
+# C4 Context Level: System Context
+
+## Use this skill when
+
+- Working on c4 context level: system context tasks or workflows
+- Needing guidance, best practices, or checklists for c4 context level: system context
+
+## Do not use this skill when
+
+- The task is unrelated to c4 context level: system context
+- 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`.
+
+## System Overview
+
+### Short Description
+
+[One-sentence description of what the system does]
+
+### Long Description
+
+[Detailed description of the system's purpose, capabilities, and the problems it solves]
+
+## Personas
+
+### [Persona Name]
+
+- **Type**: [Human User / Programmatic User / External System]
+- **Description**: [Who this persona is and what they need]
+- **Goals**: [What this persona wants to achieve]
+- **Key Features Used**: [List of features this persona uses]
+
+## System Features
+
+### [Feature Name]
+
+- **Description**: [What this feature does]
+- **Users**: [Which personas use this feature]
+- **User Journey**: [Link to user journey map]
+
+## User Journeys
+
+### [Feature Name] - [Persona Name] Journey
+
+1. [Step 1]: [Description]
+2. [Step 2]: [Description]
+3. [Step 3]: [Description]
+   ...
+
+### [External System] Integration Journey
+
+1. [Step 1]: [Description]
+2. [Step 2]: [Description]
+   ...
+
+## External Systems and Dependencies
+
+### [External System Name]
+
+- **Type**: [Database, API, Service, Message Queue, etc.]
+- **Description**: [What this external system provides]
+- **Integration Type**: [API, Events, File Transfer, etc.]
+- **Purpose**: [Why the system depends on this]
+
+## System Context Diagram
+
+[Mermaid diagram showing system, users, and external systems]
+
+## Related Documentation
+
+- [Container Documentation](./c4-container.md)
+- [Component Documentation](./c4-component.md)
+```
+
+## Context Diagram Template
+
+According to the [C4 model](https://c4model.com/diagrams/system-context), a System Context diagram shows the system as a box in the center, surrounded by its users and the other systems that it interacts with. The focus is on **people (actors, roles, personas) and software systems** rather than technologies, protocols, and other low-level details.
+
+Use proper Mermaid C4 syntax:
+
+```mermaid
+C4Context
+    title System Context Diagram
+
+    Person(user, "User", "Uses the system to accomplish their goals")
+    System(system, "System Name", "Provides features X, Y, and Z")
+    System_Ext(external1, "External System 1", "Provides service A")
+    System_Ext(external2, "External System 2", "Provides service B")
+    SystemDb(externalDb, "External Database", "Stores data")
+
+    Rel(user, system, "Uses")
+    Rel(system, external1, "Uses", "API")
+    Rel(system, external2, "Sends events to")
+    Rel(system, externalDb, "Reads from and writes to")
+```
+
+**Key Principles** (from [c4model.com](https://c4model.com/diagrams/system-context)):
+
+- Focus on **people and software systems**, not technologies
+- Show the **system boundary** clearly
+- Include all **users** (human and programmatic)
+- Include all **external systems** the system interacts with
+- Keep it **stakeholder-friendly** - understandable by non-technical audiences
+- Avoid showing technologies, protocols, or low-level details
+
+## Example Interactions
+
+- "Create C4 Context-level documentation for the system"
+- "Identify all personas and create user journey maps for key features"
+- "Document external systems and create a system context diagram"
+- "Analyze system documentation and create comprehensive context documentation"
+- "Map user journeys for all key features including programmatic users"
+
+## Key Distinctions
+
+- **vs C4-Container agent**: Provides high-level system view; Container agent focuses on deployment architecture
+- **vs C4-Component agent**: Focuses on system context; Component agent focuses on logical component structure
+- **vs C4-Code agent**: Provides stakeholder-friendly overview; Code agent provides technical code details
+
+## Output Examples
+
+When creating context documentation, provide:
+
+- Clear system descriptions (short and long)
+- Comprehensive persona documentation (human and programmatic)
+- Complete feature lists with descriptions
+- Detailed user journey maps for all key features
+- Complete external system and dependency documentation
+- Mermaid context diagram showing system, users, and external systems
+- Links to container and component documentation
+- Stakeholder-friendly documentation understandable by non-technical audiences
+- Consistent documentation format

package/skills/cal-com-automation/SKILL.md

@@ -0,0 +1,203 @@
+---
+name: cal-com-automation
+description: "Automate Cal.com tasks via Rube MCP (Composio): manage bookings, check availability, configure webhooks, and handle teams. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Cal.com Automation via Rube MCP
+
+Automate Cal.com scheduling operations through Composio's Cal toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Cal.com connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `cal`
+- 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 `cal`
+3. If connection is not ACTIVE, follow the returned auth link to complete Cal.com authentication
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Manage Bookings
+
+**When to use**: User wants to list, create, or review bookings
+
+**Tool sequence**:
+1. `CAL_FETCH_ALL_BOOKINGS` - List all bookings with filters [Required]
+2. `CAL_POST_NEW_BOOKING_REQUEST` - Create a new booking [Optional]
+
+**Key parameters for listing**:
+- `status`: Filter by booking status ('upcoming', 'recurring', 'past', 'cancelled', 'unconfirmed')
+- `afterStart`: Filter bookings after this date (ISO 8601)
+- `beforeEnd`: Filter bookings before this date (ISO 8601)
+
+**Key parameters for creation**:
+- `eventTypeId`: Event type ID for the booking
+- `start`: Booking start time (ISO 8601)
+- `end`: Booking end time (ISO 8601)
+- `name`: Attendee name
+- `email`: Attendee email
+- `timeZone`: Attendee timezone (IANA format)
+- `language`: Attendee language code
+- `metadata`: Additional metadata object
+
+**Pitfalls**:
+- Date filters use ISO 8601 format with timezone (e.g., '2024-01-15T09:00:00Z')
+- `eventTypeId` must reference a valid, active event type
+- Booking creation requires matching an available slot; check availability first
+- Time zone must be a valid IANA timezone string (e.g., 'America/New_York')
+- Status filter values are specific strings; invalid values return empty results
+
+### 2. Check Availability
+
+**When to use**: User wants to find free/busy times or available booking slots
+
+**Tool sequence**:
+1. `CAL_RETRIEVE_CALENDAR_BUSY_TIMES` - Get busy time blocks [Required]
+2. `CAL_GET_AVAILABLE_SLOTS_INFO` - Get specific available slots [Required]
+
+**Key parameters**:
+- `dateFrom`: Start date for availability check (YYYY-MM-DD)
+- `dateTo`: End date for availability check (YYYY-MM-DD)
+- `eventTypeId`: Event type to check slots for
+- `timeZone`: Timezone for the availability response
+- `loggedInUsersTz`: Timezone of the requesting user
+
+**Pitfalls**:
+- Busy times show when the user is NOT available
+- Available slots are specific to an event type's duration and configuration
+- Date range should be reasonable (not months in advance) to get accurate results
+- Timezone affects how slots are displayed; always specify explicitly
+- Availability reflects calendar integrations (Google Calendar, Outlook, etc.)
+
+### 3. Configure Webhooks
+
+**When to use**: User wants to set up or manage webhook notifications for booking events
+
+**Tool sequence**:
+1. `CAL_RETRIEVE_WEBHOOKS_LIST` - List existing webhooks [Required]
+2. `CAL_GET_WEBHOOK_BY_ID` - Get specific webhook details [Optional]
+3. `CAL_UPDATE_WEBHOOK_BY_ID` - Update webhook configuration [Optional]
+4. `CAL_DELETE_WEBHOOK_BY_ID` - Remove a webhook [Optional]
+
+**Key parameters**:
+- `id`: Webhook ID for GET/UPDATE/DELETE operations
+- `subscriberUrl`: Webhook endpoint URL
+- `eventTriggers`: Array of event types to trigger on
+- `active`: Whether the webhook is active
+- `secret`: Webhook signing secret
+
+**Pitfalls**:
+- Webhook URLs must be publicly accessible HTTPS endpoints
+- Event triggers include: 'BOOKING_CREATED', 'BOOKING_RESCHEDULED', 'BOOKING_CANCELLED', etc.
+- Inactive webhooks do not fire; toggle `active` to enable/disable
+- Webhook secrets are used for payload signature verification
+
+### 4. Manage Teams
+
+**When to use**: User wants to create, view, or manage teams and team event types
+
+**Tool sequence**:
+1. `CAL_GET_TEAMS_LIST` - List all teams [Required]
+2. `CAL_GET_TEAM_INFORMATION_BY_TEAM_ID` - Get specific team details [Optional]
+3. `CAL_CREATE_TEAM_IN_ORGANIZATION` - Create a new team [Optional]
+4. `CAL_RETRIEVE_TEAM_EVENT_TYPES` - List event types for a team [Optional]
+
+**Key parameters**:
+- `teamId`: Team identifier
+- `name`: Team name (for creation)
+- `slug`: URL-friendly team identifier
+
+**Pitfalls**:
+- Team creation may require organization-level permissions
+- Team event types are separate from personal event types
+- Team slugs must be URL-safe and unique within the organization
+
+### 5. Organization Management
+
+**When to use**: User wants to view organization details
+
+**Tool sequence**:
+1. `CAL_GET_ORGANIZATION_ID` - Get the organization ID [Required]
+
+**Key parameters**: (none required)
+
+**Pitfalls**:
+- Organization ID is needed for team creation and org-level operations
+- Not all Cal.com accounts have organizations; personal plans may return errors
+
+## Common Patterns
+
+### Booking Creation Flow
+
+```
+1. Call CAL_GET_AVAILABLE_SLOTS_INFO to find open slots
+2. Present available times to the user
+3. Call CAL_POST_NEW_BOOKING_REQUEST with selected slot
+4. Confirm booking creation response
+```
+
+### ID Resolution
+
+**Team name -> Team ID**:
+```
+1. Call CAL_GET_TEAMS_LIST
+2. Find team by name in response
+3. Extract id field
+```
+
+### Webhook Setup
+
+```
+1. Call CAL_RETRIEVE_WEBHOOKS_LIST to check existing hooks
+2. Create or update webhook with desired triggers
+3. Verify webhook fires on test booking
+```
+
+## Known Pitfalls
+
+**Date/Time Formats**:
+- Booking times: ISO 8601 with timezone (e.g., '2024-01-15T09:00:00Z')
+- Availability dates: YYYY-MM-DD format
+- Always specify timezone explicitly to avoid confusion
+
+**Event Types**:
+- Event type IDs are numeric integers
+- Event types define duration, location, and booking rules
+- Disabled event types cannot accept new bookings
+
+**Permissions**:
+- Team operations require team membership or admin access
+- Organization operations require org-level permissions
+- Webhook management requires appropriate access level
+
+**Rate Limits**:
+- Cal.com API has rate limits per API key
+- Implement backoff on 429 responses
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List bookings | CAL_FETCH_ALL_BOOKINGS | status, afterStart, beforeEnd |
+| Create booking | CAL_POST_NEW_BOOKING_REQUEST | eventTypeId, start, end, name, email |
+| Get busy times | CAL_RETRIEVE_CALENDAR_BUSY_TIMES | dateFrom, dateTo |
+| Get available slots | CAL_GET_AVAILABLE_SLOTS_INFO | eventTypeId, dateFrom, dateTo |
+| List webhooks | CAL_RETRIEVE_WEBHOOKS_LIST | (none) |
+| Get webhook | CAL_GET_WEBHOOK_BY_ID | id |
+| Update webhook | CAL_UPDATE_WEBHOOK_BY_ID | id, subscriberUrl, eventTriggers |
+| Delete webhook | CAL_DELETE_WEBHOOK_BY_ID | id |
+| List teams | CAL_GET_TEAMS_LIST | (none) |
+| Get team | CAL_GET_TEAM_INFORMATION_BY_TEAM_ID | teamId |
+| Create team | CAL_CREATE_TEAM_IN_ORGANIZATION | name, slug |
+| Team event types | CAL_RETRIEVE_TEAM_EVENT_TYPES | teamId |
+| Get org ID | CAL_GET_ORGANIZATION_ID | (none) |