skill-library-mcp 1.0.0

package/skills/microsoft-teams-automation/SKILL.md

@@ -0,0 +1,211 @@
+---
+name: microsoft-teams-automation
+description: "Automate Microsoft Teams tasks via Rube MCP (Composio): send messages, manage channels, create meetings, handle chats, and search messages. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Microsoft Teams Automation via Rube MCP
+
+Automate Microsoft Teams operations through Composio's Microsoft Teams toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Microsoft Teams connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `microsoft_teams`
+- 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 `microsoft_teams`
+3. If connection is not ACTIVE, follow the returned auth link to complete Microsoft OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Send Channel Messages
+
+**When to use**: User wants to post a message to a Teams channel
+
+**Tool sequence**:
+1. `MICROSOFT_TEAMS_TEAMS_LIST` - List teams to find target team [Prerequisite]
+2. `MICROSOFT_TEAMS_TEAMS_LIST_CHANNELS` - List channels in the team [Prerequisite]
+3. `MICROSOFT_TEAMS_TEAMS_POST_CHANNEL_MESSAGE` - Post the message [Required]
+
+**Key parameters**:
+- `team_id`: UUID of the team (from TEAMS_LIST)
+- `channel_id`: Channel ID (from LIST_CHANNELS, format: '19:...@thread.tacv2')
+- `content`: Message text or HTML
+- `content_type`: 'text' or 'html'
+
+**Pitfalls**:
+- team_id must be a valid UUID format
+- channel_id must be in thread format (e.g., '19:abc@thread.tacv2')
+- TEAMS_LIST may paginate (~100 items/page); follow @odata.nextLink to find all teams
+- LIST_CHANNELS can return 403 if user lacks access to the team
+- Messages over ~28KB can trigger 400/413 errors; split long content
+- Throttling may return 429; use exponential backoff (1s/2s/4s)
+
+### 2. Send Chat Messages
+
+**When to use**: User wants to send a direct or group chat message
+
+**Tool sequence**:
+1. `MICROSOFT_TEAMS_CHATS_GET_ALL_CHATS` - List existing chats [Optional]
+2. `MICROSOFT_TEAMS_LIST_USERS` - Find users for new chats [Optional]
+3. `MICROSOFT_TEAMS_TEAMS_CREATE_CHAT` - Create a new chat [Optional]
+4. `MICROSOFT_TEAMS_TEAMS_POST_CHAT_MESSAGE` - Send the message [Required]
+
+**Key parameters**:
+- `chat_id`: Chat ID (from GET_ALL_CHATS or CREATE_CHAT)
+- `content`: Message content
+- `content_type`: 'text' or 'html'
+- `chatType`: 'oneOnOne' or 'group' (for CREATE_CHAT)
+- `members`: Array of member objects (for CREATE_CHAT)
+
+**Pitfalls**:
+- CREATE_CHAT requires the authenticated user as one of the members
+- oneOnOne chats return existing chat if one already exists between the two users
+- group chats require at least one member with 'owner' role
+- member user_odata_bind must use full Microsoft Graph URL format
+- Chat filter support is very limited; filter client-side when needed
+
+### 3. Create Online Meetings
+
+**When to use**: User wants to schedule a Microsoft Teams meeting
+
+**Tool sequence**:
+1. `MICROSOFT_TEAMS_LIST_USERS` - Find participant user IDs [Optional]
+2. `MICROSOFT_TEAMS_CREATE_MEETING` - Create the meeting [Required]
+
+**Key parameters**:
+- `subject`: Meeting title
+- `start_date_time`: ISO 8601 start time (e.g., '2024-08-15T10:00:00Z')
+- `end_date_time`: ISO 8601 end time (must be after start)
+- `participants`: Array of user objects with user_id and role
+
+**Pitfalls**:
+- end_date_time must be strictly after start_date_time
+- Participants require valid Microsoft user_id (GUID) values, not emails
+- This creates a standalone meeting not linked to a calendar event
+- For calendar-linked meetings, use OUTLOOK_CALENDAR_CREATE_EVENT with is_online_meeting=true
+
+### 4. Manage Teams and Channels
+
+**When to use**: User wants to list, create, or manage teams and channels
+
+**Tool sequence**:
+1. `MICROSOFT_TEAMS_TEAMS_LIST` - List all accessible teams [Required]
+2. `MICROSOFT_TEAMS_GET_TEAM` - Get details for a specific team [Optional]
+3. `MICROSOFT_TEAMS_TEAMS_LIST_CHANNELS` - List channels in a team [Optional]
+4. `MICROSOFT_TEAMS_GET_CHANNEL` - Get channel details [Optional]
+5. `MICROSOFT_TEAMS_TEAMS_CREATE_CHANNEL` - Create a new channel [Optional]
+6. `MICROSOFT_TEAMS_LIST_TEAM_MEMBERS` - List team members [Optional]
+7. `MICROSOFT_TEAMS_ADD_MEMBER_TO_TEAM` - Add a member to the team [Optional]
+
+**Key parameters**:
+- `team_id`: Team UUID
+- `channel_id`: Channel ID in thread format
+- `filter`: OData filter string (e.g., "startsWith(displayName,'Project')")
+- `select`: Comma-separated properties to return
+
+**Pitfalls**:
+- TEAMS_LIST pagination: follow @odata.nextLink in large tenants
+- Private/shared channels may be omitted unless permissions align
+- GET_CHANNEL returns 404 if team_id or channel_id is wrong
+- Always source IDs from list operations; do not guess ID formats
+
+### 5. Search Messages
+
+**When to use**: User wants to find messages across Teams chats and channels
+
+**Tool sequence**:
+1. `MICROSOFT_TEAMS_SEARCH_MESSAGES` - Search with KQL syntax [Required]
+
+**Key parameters**:
+- `query`: KQL search query (supports from:, sent:, attachments, boolean logic)
+
+**Pitfalls**:
+- Newly posted messages may take 30-60 seconds to appear in search
+- Search is eventually consistent; do not rely on it for immediate delivery confirmation
+- Use message listing tools for real-time message verification
+
+## Common Patterns
+
+### Team and Channel ID Resolution
+
+```
+1. Call MICROSOFT_TEAMS_TEAMS_LIST
+2. Find team by displayName
+3. Extract team id (UUID format)
+4. Call MICROSOFT_TEAMS_TEAMS_LIST_CHANNELS with team_id
+5. Find channel by displayName
+6. Extract channel id (19:...@thread.tacv2 format)
+```
+
+### User Resolution
+
+```
+1. Call MICROSOFT_TEAMS_LIST_USERS
+2. Filter by displayName or email
+3. Extract user id (UUID format)
+4. Use for meeting participants, chat members, or team operations
+```
+
+### Pagination
+
+- Teams/Users: Follow @odata.nextLink URL for next page
+- Chats: Auto-paginates up to limit; use top for page size (max 50)
+- Use `top` parameter to control page size
+- Continue until @odata.nextLink is absent
+
+## Known Pitfalls
+
+**Authentication and Permissions**:
+- Different operations require different Microsoft Graph permissions
+- 403 errors indicate insufficient permissions or team access
+- Some operations require admin consent in the Azure AD tenant
+
+**ID Formats**:
+- Team IDs: UUID format (e.g., '87b0560f-fc0d-4442-add8-b380ca926707')
+- Channel IDs: Thread format (e.g., '19:abc123@thread.tacv2')
+- Chat IDs: Various formats (e.g., '19:meeting_xxx@thread.v2')
+- User IDs: UUID format
+- Never guess IDs; always resolve from list operations
+
+**Rate Limits**:
+- Microsoft Graph enforces throttling
+- 429 responses include Retry-After header
+- Keep requests to a few per second
+- Batch operations help reduce total request count
+
+**Message Formatting**:
+- HTML content_type supports rich formatting
+- Adaptive cards require additional handling
+- Message size limit is approximately 28KB
+- Split long content into multiple messages
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List teams | MICROSOFT_TEAMS_TEAMS_LIST | filter, select, top |
+| Get team details | MICROSOFT_TEAMS_GET_TEAM | team_id |
+| List channels | MICROSOFT_TEAMS_TEAMS_LIST_CHANNELS | team_id, filter |
+| Get channel | MICROSOFT_TEAMS_GET_CHANNEL | team_id, channel_id |
+| Create channel | MICROSOFT_TEAMS_TEAMS_CREATE_CHANNEL | team_id, displayName |
+| Post to channel | MICROSOFT_TEAMS_TEAMS_POST_CHANNEL_MESSAGE | team_id, channel_id, content |
+| List chats | MICROSOFT_TEAMS_CHATS_GET_ALL_CHATS | user_id, limit |
+| Create chat | MICROSOFT_TEAMS_TEAMS_CREATE_CHAT | chatType, members, topic |
+| Post to chat | MICROSOFT_TEAMS_TEAMS_POST_CHAT_MESSAGE | chat_id, content |
+| Create meeting | MICROSOFT_TEAMS_CREATE_MEETING | subject, start_date_time, end_date_time |
+| List users | MICROSOFT_TEAMS_LIST_USERS | filter, select, top |
+| List team members | MICROSOFT_TEAMS_LIST_TEAM_MEMBERS | team_id |
+| Add team member | MICROSOFT_TEAMS_ADD_MEMBER_TO_TEAM | team_id, user_id |
+| Search messages | MICROSOFT_TEAMS_SEARCH_MESSAGES | query |
+| Get chat message | MICROSOFT_TEAMS_GET_CHAT_MESSAGE | chat_id, message_id |
+| List joined teams | MICROSOFT_TEAMS_LIST_USER_JOINED_TEAMS | (none) |

package/skills/minecraft-bukkit-pro/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: minecraft-bukkit-pro
+description: Master Minecraft server plugin development with Bukkit, Spigot, and
+  Paper APIs. Specializes in event-driven architecture, command systems, world
+  manipulation, player management, and performance optimization. Use PROACTIVELY
+  for plugin architecture, gameplay mechanics, server-side features, or
+  cross-version compatibility.
+metadata:
+  model: opus
+---
+
+## Use this skill when
+
+- Working on minecraft bukkit pro tasks or workflows
+- Needing guidance, best practices, or checklists for minecraft bukkit pro
+
+## Do not use this skill when
+
+- The task is unrelated to minecraft bukkit pro
+- 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`.
+
+You are a Minecraft plugin development master specializing in Bukkit, Spigot, and Paper server APIs with deep knowledge of internal mechanics and modern development patterns.
+
+## Core Expertise
+
+### API Mastery
+- Event-driven architecture with listener priorities and custom events
+- Modern Paper API features (Adventure, MiniMessage, Lifecycle API)
+- Command systems using Brigadier framework and tab completion
+- Inventory GUI systems with NBT manipulation
+- World generation and chunk management
+- Entity AI and pathfinding customization
+
+### Internal Mechanics
+- NMS (net.minecraft.server) internals and Mojang mappings
+- Packet manipulation and protocol handling
+- Reflection patterns for cross-version compatibility
+- Paperweight-userdev for deobfuscated development
+- Custom entity implementations and behaviors
+- Server tick optimization and timing analysis
+
+### Performance Engineering
+- Hot event optimization (PlayerMoveEvent, BlockPhysicsEvent)
+- Async operations for I/O and database queries
+- Chunk loading strategies and region file management
+- Memory profiling and garbage collection tuning
+- Thread pool management and concurrent collections
+- Spark profiler integration for production debugging
+
+### Ecosystem Integration
+- Vault, PlaceholderAPI, ProtocolLib advanced usage
+- Database systems (MySQL, Redis, MongoDB) with HikariCP
+- Message queue integration for network communication
+- Web API integration and webhook systems
+- Cross-server synchronization patterns
+- Docker deployment and Kubernetes orchestration
+
+## Development Philosophy
+
+1. **Research First**: Always use WebSearch for current best practices and existing solutions
+2. **Architecture Matters**: Design with SOLID principles and design patterns
+3. **Performance Critical**: Profile before optimizing, measure impact
+4. **Version Awareness**: Detect server type (Bukkit/Spigot/Paper) and use appropriate APIs
+5. **Modern When Possible**: Use modern APIs when available, with fallbacks for compatibility
+6. **Test Everything**: Unit tests with MockBukkit, integration tests on real servers
+
+## Technical Approach
+
+### Project Analysis
+- Examine build configuration for dependencies and target versions
+- Identify existing patterns and architectural decisions
+- Assess performance requirements and scalability needs
+- Review security implications and attack vectors
+
+### Implementation Strategy
+- Start with minimal viable functionality
+- Layer in features with proper separation of concerns
+- Implement comprehensive error handling and recovery
+- Add metrics and monitoring hooks
+- Document with JavaDoc and user guides
+
+### Quality Standards
+- Follow Google Java Style Guide
+- Implement defensive programming practices
+- Use immutable objects and builder patterns
+- Apply dependency injection where appropriate
+- Maintain backward compatibility when possible
+
+## Output Excellence
+
+### Code Structure
+- Clean package organization by feature
+- Service layer for business logic
+- Repository pattern for data access
+- Factory pattern for object creation
+- Event bus for internal communication
+
+### Configuration
+- YAML with detailed comments and examples
+- Version-appropriate text formatting (MiniMessage for Paper, legacy for Bukkit/Spigot)
+- Gradual migration paths for config updates
+- Environment variable support for containers
+- Feature flags for experimental functionality
+
+### Build System
+- Maven/Gradle with proper dependency management
+- Shade/shadow for dependency relocation
+- Multi-module projects for version abstraction
+- CI/CD integration with automated testing
+- Semantic versioning and changelog generation
+
+### Documentation
+- Comprehensive README with quick start
+- Wiki documentation for advanced features
+- API documentation for developer extensions
+- Migration guides for version updates
+- Performance tuning guidelines
+
+Always leverage WebSearch and WebFetch to ensure best practices and find existing solutions. Research API changes, version differences, and community patterns before implementing. Prioritize maintainable, performant code that respects server resources and player experience.

package/skills/miro-automation/SKILL.md

@@ -0,0 +1,205 @@
+---
+name: miro-automation
+description: "Automate Miro tasks via Rube MCP (Composio): boards, items, sticky notes, frames, sharing, connectors. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Miro Automation via Rube MCP
+
+Automate Miro whiteboard operations through Composio's Miro toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Miro connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `miro`
+- 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 `miro`
+3. If connection is not ACTIVE, follow the returned auth link to complete Miro OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. List and Browse Boards
+
+**When to use**: User wants to find boards or get board details
+
+**Tool sequence**:
+1. `MIRO_GET_BOARDS2` - List all accessible boards [Required]
+2. `MIRO_GET_BOARD` - Get detailed info for a specific board [Optional]
+
+**Key parameters**:
+- `query`: Search term to filter boards by name
+- `sort`: Sort by 'default', 'last_modified', 'last_opened', 'last_created', 'alphabetically'
+- `limit`: Number of results per page (max 50)
+- `offset`: Pagination offset
+- `board_id`: Specific board ID for detailed retrieval
+
+**Pitfalls**:
+- Pagination uses offset-based approach, not cursor-based
+- Maximum 50 boards per page; iterate with offset for full list
+- Board IDs are long alphanumeric strings; always resolve by search first
+
+### 2. Create Boards and Items
+
+**When to use**: User wants to create a new board or add items to an existing board
+
+**Tool sequence**:
+1. `MIRO_CREATE_BOARD` - Create a new empty board [Optional]
+2. `MIRO_CREATE_STICKY_NOTE_ITEM` - Add sticky notes to a board [Optional]
+3. `MIRO_CREATE_FRAME_ITEM2` - Add frames to organize content [Optional]
+4. `MIRO_CREATE_ITEMS_IN_BULK` - Add multiple items at once [Optional]
+
+**Key parameters**:
+- `name` / `description`: Board name and description (for CREATE_BOARD)
+- `board_id`: Target board ID (required for all item creation)
+- `data`: Content object with `content` field for sticky note text
+- `style`: Styling object with `fillColor` for sticky note color
+- `position`: Object with `x` and `y` coordinates
+- `geometry`: Object with `width` and `height`
+
+**Pitfalls**:
+- `board_id` is required for ALL item operations; resolve via GET_BOARDS2 first
+- Sticky note colors use hex codes (e.g., '#FF0000') in the `fillColor` field
+- Position coordinates use the board's coordinate system (origin at center)
+- BULK create has a maximum items-per-request limit; check current schema
+- Frame items require `geometry` with both width and height
+
+### 3. Browse and Manage Board Items
+
+**When to use**: User wants to view, find, or organize items on a board
+
+**Tool sequence**:
+1. `MIRO_GET_BOARD_ITEMS` - List all items on a board [Required]
+2. `MIRO_GET_CONNECTORS2` - List connections between items [Optional]
+
+**Key parameters**:
+- `board_id`: Target board ID (required)
+- `type`: Filter by item type ('sticky_note', 'shape', 'text', 'frame', 'image', 'card')
+- `limit`: Number of items per page
+- `cursor`: Pagination cursor from previous response
+
+**Pitfalls**:
+- Results are paginated; follow `cursor` until absent for complete item list
+- Item types must match Miro's predefined types exactly
+- Large boards may have thousands of items; use type filtering to narrow results
+- Connectors are separate from items; use GET_CONNECTORS2 for relationship data
+
+### 4. Share and Collaborate on Boards
+
+**When to use**: User wants to share a board with team members or manage access
+
+**Tool sequence**:
+1. `MIRO_GET_BOARDS2` - Find the board to share [Prerequisite]
+2. `MIRO_SHARE_BOARD` - Share the board with users [Required]
+3. `MIRO_GET_BOARD_MEMBERS` - Verify current board members [Optional]
+
+**Key parameters**:
+- `board_id`: Board to share (required)
+- `emails`: Array of email addresses to invite
+- `role`: Access level ('viewer', 'commenter', 'editor')
+- `message`: Optional invitation message
+
+**Pitfalls**:
+- Email addresses must be valid; invalid emails cause the entire request to fail
+- Role must be one of the predefined values; case-sensitive
+- Sharing with users outside the organization may require admin approval
+- GET_BOARD_MEMBERS returns all members including the owner
+
+### 5. Create Visual Connections
+
+**When to use**: User wants to connect items on a board with lines or arrows
+
+**Tool sequence**:
+1. `MIRO_GET_BOARD_ITEMS` - Find items to connect [Prerequisite]
+2. `MIRO_GET_CONNECTORS2` - View existing connections [Optional]
+
+**Key parameters**:
+- `board_id`: Target board ID
+- `startItem`: Object with `id` of the source item
+- `endItem`: Object with `id` of the target item
+- `style`: Connector style (line type, color, arrows)
+
+**Pitfalls**:
+- Both start and end items must exist on the same board
+- Item IDs are required for connections; resolve via GET_BOARD_ITEMS first
+- Connector styles vary; check available options in schema
+- Self-referencing connections (same start and end) are not allowed
+
+## Common Patterns
+
+### ID Resolution
+
+**Board name -> Board ID**:
+```
+1. Call MIRO_GET_BOARDS2 with query=board_name
+2. Find board by name in results
+3. Extract id field
+```
+
+**Item lookup on board**:
+```
+1. Call MIRO_GET_BOARD_ITEMS with board_id and optional type filter
+2. Find item by content or position
+3. Extract item id for further operations
+```
+
+### Pagination
+
+- Boards: Use `offset` and `limit` (offset-based)
+- Board items: Use `cursor` and `limit` (cursor-based)
+- Continue until no more results or cursor is absent
+- Default page sizes vary by endpoint
+
+### Coordinate System
+
+- Board origin (0,0) is at the center
+- Positive X is right, positive Y is down
+- Items positioned by their center point
+- Use `position: {x: 0, y: 0}` for center of board
+- Frames define bounded areas; items inside inherit frame position
+
+## Known Pitfalls
+
+**Board IDs**:
+- Board IDs are required for virtually all operations
+- Always resolve board names to IDs via GET_BOARDS2 first
+- Do not hardcode board IDs; they vary by account
+
+**Item Creation**:
+- Each item type has different required fields
+- Sticky notes need `data.content` for text
+- Frames need `geometry.width` and `geometry.height`
+- Position defaults to (0,0) if not specified; items may overlap
+
+**Rate Limits**:
+- Miro API has rate limits per token
+- Bulk operations preferred over individual item creation
+- Use MIRO_CREATE_ITEMS_IN_BULK for multiple items
+
+**Response Parsing**:
+- Response data may be nested under `data` key
+- Item types determine which fields are present in response
+- Parse defensively; optional fields may be absent
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List boards | MIRO_GET_BOARDS2 | query, sort, limit, offset |
+| Get board details | MIRO_GET_BOARD | board_id |
+| Create board | MIRO_CREATE_BOARD | name, description |
+| Add sticky note | MIRO_CREATE_STICKY_NOTE_ITEM | board_id, data, style, position |
+| Add frame | MIRO_CREATE_FRAME_ITEM2 | board_id, data, geometry, position |
+| Bulk add items | MIRO_CREATE_ITEMS_IN_BULK | board_id, items |
+| Get board items | MIRO_GET_BOARD_ITEMS | board_id, type, cursor |
+| Share board | MIRO_SHARE_BOARD | board_id, emails, role |
+| Get members | MIRO_GET_BOARD_MEMBERS | board_id |
+| Get connectors | MIRO_GET_CONNECTORS2 | board_id |