skill-library-mcp 1.0.0

package/skills/documentation-templates/SKILL.md

@@ -0,0 +1,194 @@
+---
+name: documentation-templates
+description: Documentation templates and structure guidelines. README, API docs, code comments, and AI-friendly documentation.
+allowed-tools: Read, Glob, Grep
+---
+
+# Documentation Templates
+
+> Templates and structure guidelines for common documentation types.
+
+---
+
+## 1. README Structure
+
+### Essential Sections (Priority Order)
+
+| Section | Purpose |
+|---------|---------|
+| **Title + One-liner** | What is this? |
+| **Quick Start** | Running in <5 min |
+| **Features** | What can I do? |
+| **Configuration** | How to customize |
+| **API Reference** | Link to detailed docs |
+| **Contributing** | How to help |
+| **License** | Legal |
+
+### README Template
+
+```markdown
+# Project Name
+
+Brief one-line description.
+
+## Quick Start
+
+[Minimum steps to run]
+
+## Features
+
+- Feature 1
+- Feature 2
+
+## Configuration
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| PORT | Server port | 3000 |
+
+## Documentation
+
+- [API Reference](./docs/api.md)
+- [Architecture](./docs/architecture.md)
+
+## License
+
+MIT
+```
+
+---
+
+## 2. API Documentation Structure
+
+### Per-Endpoint Template
+
+```markdown
+## GET /users/:id
+
+Get a user by ID.
+
+**Parameters:**
+| Name | Type | Required | Description |
+|------|------|----------|-------------|
+| id | string | Yes | User ID |
+
+**Response:**
+- 200: User object
+- 404: User not found
+
+**Example:**
+[Request and response example]
+```
+
+---
+
+## 3. Code Comment Guidelines
+
+### JSDoc/TSDoc Template
+
+```typescript
+/**
+ * Brief description of what the function does.
+ * 
+ * @param paramName - Description of parameter
+ * @returns Description of return value
+ * @throws ErrorType - When this error occurs
+ * 
+ * @example
+ * const result = functionName(input);
+ */
+```
+
+### When to Comment
+
+| ✅ Comment | ❌ Don't Comment |
+|-----------|-----------------|
+| Why (business logic) | What (obvious) |
+| Complex algorithms | Every line |
+| Non-obvious behavior | Self-explanatory code |
+| API contracts | Implementation details |
+
+---
+
+## 4. Changelog Template (Keep a Changelog)
+
+```markdown
+# Changelog
+
+## [Unreleased]
+### Added
+- New feature
+
+## [1.0.0] - 2025-01-01
+### Added
+- Initial release
+### Changed
+- Updated dependency
+### Fixed
+- Bug fix
+```
+
+---
+
+## 5. Architecture Decision Record (ADR)
+
+```markdown
+# ADR-001: [Title]
+
+## Status
+Accepted / Deprecated / Superseded
+
+## Context
+Why are we making this decision?
+
+## Decision
+What did we decide?
+
+## Consequences
+What are the trade-offs?
+```
+
+---
+
+## 6. AI-Friendly Documentation (2025)
+
+### llms.txt Template
+
+For AI crawlers and agents:
+
+```markdown
+# Project Name
+> One-line objective.
+
+## Core Files
+- [src/index.ts]: Main entry
+- [src/api/]: API routes
+- [docs/]: Documentation
+
+## Key Concepts
+- Concept 1: Brief explanation
+- Concept 2: Brief explanation
+```
+
+### MCP-Ready Documentation
+
+For RAG indexing:
+- Clear H1-H3 hierarchy
+- JSON/YAML examples for data structures
+- Mermaid diagrams for flows
+- Self-contained sections
+
+---
+
+## 7. Structure Principles
+
+| Principle | Why |
+|-----------|-----|
+| **Scannable** | Headers, lists, tables |
+| **Examples first** | Show, don't just tell |
+| **Progressive detail** | Simple → Complex |
+| **Up to date** | Outdated = misleading |
+
+---
+
+> **Remember:** Templates are starting points. Adapt to your project's needs.

package/skills/docusign-automation/SKILL.md

@@ -0,0 +1,208 @@
+---
+name: docusign-automation
+description: "Automate DocuSign tasks via Rube MCP (Composio): templates, envelopes, signatures, document management. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# DocuSign Automation via Rube MCP
+
+Automate DocuSign e-signature workflows through Composio's DocuSign toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active DocuSign connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `docusign`
+- 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 `docusign`
+3. If connection is not ACTIVE, follow the returned auth link to complete DocuSign OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Browse and Select Templates
+
+**When to use**: User wants to find available document templates for sending
+
+**Tool sequence**:
+1. `DOCUSIGN_LIST_ALL_TEMPLATES` - List all available templates [Required]
+2. `DOCUSIGN_GET_TEMPLATE` - Get detailed template information [Optional]
+
+**Key parameters**:
+- For listing: Optional search/filter parameters
+- For details: `templateId` (from list results)
+- Response includes template `templateId`, `name`, `description`, roles, and fields
+
+**Pitfalls**:
+- Template IDs are GUIDs (e.g., '12345678-abcd-1234-efgh-123456789012')
+- Templates define recipient roles with signing tabs; understand roles before creating envelopes
+- Large template libraries require pagination; check for continuation tokens
+- Template access depends on account permissions
+
+### 2. Create and Send Envelopes from Templates
+
+**When to use**: User wants to send documents for signature using a pre-built template
+
+**Tool sequence**:
+1. `DOCUSIGN_LIST_ALL_TEMPLATES` - Find the template to use [Prerequisite]
+2. `DOCUSIGN_GET_TEMPLATE` - Review template roles and fields [Optional]
+3. `DOCUSIGN_CREATE_ENVELOPE_FROM_TEMPLATE` - Create the envelope [Required]
+4. `DOCUSIGN_SEND_ENVELOPE` - Send the envelope for signing [Required]
+
+**Key parameters**:
+- For CREATE_ENVELOPE_FROM_TEMPLATE:
+  - `templateId`: Template to use
+  - `templateRoles`: Array of role assignments with `roleName`, `name`, `email`
+  - `status`: 'created' (draft) or 'sent' (send immediately)
+  - `emailSubject`: Custom subject line for the signing email
+  - `emailBlurb`: Custom message in the signing email
+- For SEND_ENVELOPE:
+  - `envelopeId`: Envelope ID from creation response
+
+**Pitfalls**:
+- `templateRoles` must match the role names defined in the template exactly (case-sensitive)
+- Setting `status` to 'sent' during creation sends immediately; use 'created' for drafts
+- If status is 'sent' at creation, no need to call SEND_ENVELOPE separately
+- Each role requires at minimum `roleName`, `name`, and `email`
+- `emailSubject` overrides the template's default email subject
+
+### 3. Monitor Envelope Status
+
+**When to use**: User wants to check the status of sent envelopes or track signing progress
+
+**Tool sequence**:
+1. `DOCUSIGN_GET_ENVELOPE` - Get envelope details and status [Required]
+
+**Key parameters**:
+- `envelopeId`: Envelope identifier (GUID)
+- Response includes `status`, `recipients`, `sentDateTime`, `completedDateTime`
+
+**Pitfalls**:
+- Envelope statuses: 'created', 'sent', 'delivered', 'signed', 'completed', 'declined', 'voided'
+- 'delivered' means the email was opened, not that the document was signed
+- 'completed' means all recipients have signed
+- Recipients array shows individual signing status per recipient
+- Envelope IDs are GUIDs; always resolve from creation or search results
+
+### 4. Add Templates to Existing Envelopes
+
+**When to use**: User wants to add additional documents or templates to an existing envelope
+
+**Tool sequence**:
+1. `DOCUSIGN_GET_ENVELOPE` - Verify envelope exists and is in draft state [Prerequisite]
+2. `DOCUSIGN_ADD_TEMPLATES_TO_DOCUMENT_IN_ENVELOPE` - Add template to envelope [Required]
+
+**Key parameters**:
+- `envelopeId`: Target envelope ID
+- `documentId`: Document ID within the envelope
+- `templateId`: Template to add
+
+**Pitfalls**:
+- Envelope must be in 'created' (draft) status to add templates
+- Cannot add templates to already-sent envelopes
+- Document IDs are sequential within an envelope (starting from '1')
+- Adding a template merges its fields and roles into the existing envelope
+
+### 5. Manage Envelope Lifecycle
+
+**When to use**: User wants to send, void, or manage draft envelopes
+
+**Tool sequence**:
+1. `DOCUSIGN_GET_ENVELOPE` - Check current envelope status [Prerequisite]
+2. `DOCUSIGN_SEND_ENVELOPE` - Send a draft envelope [Optional]
+
+**Key parameters**:
+- `envelopeId`: Envelope to manage
+- For sending: envelope must be in 'created' status with all required recipients
+
+**Pitfalls**:
+- Only 'created' (draft) envelopes can be sent
+- Sent envelopes cannot be unsent; they can only be voided
+- Voiding an envelope notifies all recipients
+- All required recipients must have valid email addresses before sending
+
+## Common Patterns
+
+### ID Resolution
+
+**Template name -> Template ID**:
+```
+1. Call DOCUSIGN_LIST_ALL_TEMPLATES
+2. Find template by name in results
+3. Extract templateId (GUID format)
+```
+
+**Envelope tracking**:
+```
+1. Store envelopeId from CREATE_ENVELOPE_FROM_TEMPLATE response
+2. Call DOCUSIGN_GET_ENVELOPE periodically to check status
+3. Check recipient-level status for individual signing progress
+```
+
+### Template Role Mapping
+
+When creating an envelope from a template:
+```
+1. Call DOCUSIGN_GET_TEMPLATE to see defined roles
+2. Map each role to actual recipients:
+   {
+     "roleName": "Signer 1",     // Must match template role name exactly
+     "name": "John Smith",
+     "email": "john@example.com"
+   }
+3. Include ALL required roles in templateRoles array
+```
+
+### Envelope Status Flow
+
+```
+created (draft) -> sent -> delivered -> signed -> completed
+                       \-> declined
+                       \-> voided (by sender)
+```
+
+## Known Pitfalls
+
+**Template Roles**:
+- Role names are case-sensitive; must match template definition exactly
+- All required roles must be assigned when creating an envelope
+- Missing role assignments cause envelope creation to fail
+
+**Envelope Status**:
+- 'delivered' means email opened, NOT document signed
+- 'completed' is the final successful state (all parties signed)
+- Status transitions are one-way; cannot revert to previous states
+
+**GUIDs**:
+- All DocuSign IDs (templates, envelopes) are GUID format
+- Always resolve names to GUIDs via list/search endpoints
+- Do not hardcode GUIDs; they are unique per account
+
+**Rate Limits**:
+- DocuSign API has per-account rate limits
+- Bulk envelope creation should be throttled
+- Polling envelope status should use reasonable intervals (30-60 seconds)
+
+**Response Parsing**:
+- Response data may be nested under `data` key
+- Recipient information is nested within envelope response
+- Date fields use ISO 8601 format
+- Parse defensively with fallbacks for optional fields
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List templates | DOCUSIGN_LIST_ALL_TEMPLATES | (optional filters) |
+| Get template | DOCUSIGN_GET_TEMPLATE | templateId |
+| Create envelope | DOCUSIGN_CREATE_ENVELOPE_FROM_TEMPLATE | templateId, templateRoles, status |
+| Send envelope | DOCUSIGN_SEND_ENVELOPE | envelopeId |
+| Get envelope status | DOCUSIGN_GET_ENVELOPE | envelopeId |
+| Add template to envelope | DOCUSIGN_ADD_TEMPLATES_TO_DOCUMENT_IN_ENVELOPE | envelopeId, documentId, templateId |

package/skills/dotnet-architect/SKILL.md

@@ -0,0 +1,197 @@
+---
+name: dotnet-architect
+description: Expert .NET backend architect specializing in C#, ASP.NET Core,
+  Entity Framework, Dapper, and enterprise application patterns. Masters
+  async/await, dependency injection, caching strategies, and performance
+  optimization. Use PROACTIVELY for .NET API development, code review, or
+  architecture decisions.
+metadata:
+  model: sonnet
+---
+
+## Use this skill when
+
+- Working on dotnet architect tasks or workflows
+- Needing guidance, best practices, or checklists for dotnet architect
+
+## Do not use this skill when
+
+- The task is unrelated to dotnet architect
+- 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 an expert .NET backend architect with deep knowledge of C#, ASP.NET Core, and enterprise application patterns.
+
+## Purpose
+
+Senior .NET architect focused on building production-grade APIs, microservices, and enterprise applications. Combines deep expertise in C# language features, ASP.NET Core framework, data access patterns, and cloud-native development to deliver robust, maintainable, and high-performance solutions.
+
+## Capabilities
+
+### C# Language Mastery
+- Modern C# features (12/13): required members, primary constructors, collection expressions
+- Async/await patterns: ValueTask, IAsyncEnumerable, ConfigureAwait
+- LINQ optimization: deferred execution, expression trees, avoiding materializations
+- Memory management: Span<T>, Memory<T>, ArrayPool, stackalloc
+- Pattern matching: switch expressions, property patterns, list patterns
+- Records and immutability: record types, init-only setters, with expressions
+- Nullable reference types: proper annotation and handling
+
+### ASP.NET Core Expertise
+- Minimal APIs and controller-based APIs
+- Middleware pipeline and request processing
+- Dependency injection: lifetimes, keyed services, factory patterns
+- Configuration: IOptions, IOptionsSnapshot, IOptionsMonitor
+- Authentication/Authorization: JWT, OAuth, policy-based auth
+- Health checks and readiness/liveness probes
+- Background services and hosted services
+- Rate limiting and output caching
+
+### Data Access Patterns
+- Entity Framework Core: DbContext, configurations, migrations
+- EF Core optimization: AsNoTracking, split queries, compiled queries
+- Dapper: high-performance queries, multi-mapping, TVPs
+- Repository and Unit of Work patterns
+- CQRS: command/query separation
+- Database-first vs code-first approaches
+- Connection pooling and transaction management
+
+### Caching Strategies
+- IMemoryCache for in-process caching
+- IDistributedCache with Redis
+- Multi-level caching (L1/L2)
+- Stale-while-revalidate patterns
+- Cache invalidation strategies
+- Distributed locking with Redis
+
+### Performance Optimization
+- Profiling and benchmarking with BenchmarkDotNet
+- Memory allocation analysis
+- HTTP client optimization with IHttpClientFactory
+- Response compression and streaming
+- Database query optimization
+- Reducing GC pressure
+
+### Testing Practices
+- xUnit test framework
+- Moq for mocking dependencies
+- FluentAssertions for readable assertions
+- Integration tests with WebApplicationFactory
+- Test containers for database tests
+- Code coverage with Coverlet
+
+### Architecture Patterns
+- Clean Architecture / Onion Architecture
+- Domain-Driven Design (DDD) tactical patterns
+- CQRS with MediatR
+- Event sourcing basics
+- Microservices patterns: API Gateway, Circuit Breaker
+- Vertical slice architecture
+
+### DevOps & Deployment
+- Docker containerization for .NET
+- Kubernetes deployment patterns
+- CI/CD with GitHub Actions / Azure DevOps
+- Health monitoring with Application Insights
+- Structured logging with Serilog
+- OpenTelemetry integration
+
+## Behavioral Traits
+
+- Writes idiomatic, modern C# code following Microsoft guidelines
+- Favors composition over inheritance
+- Applies SOLID principles pragmatically
+- Prefers explicit over implicit (nullable annotations, explicit types when clearer)
+- Values testability and designs for dependency injection
+- Considers performance implications but avoids premature optimization
+- Uses async/await correctly throughout the call stack
+- Prefers records for DTOs and immutable data structures
+- Documents public APIs with XML comments
+- Handles errors gracefully with Result types or exceptions as appropriate
+
+## Knowledge Base
+
+- Microsoft .NET documentation and best practices
+- ASP.NET Core fundamentals and advanced topics
+- Entity Framework Core and Dapper patterns
+- Redis caching and distributed systems
+- xUnit, Moq, and testing strategies
+- Clean Architecture and DDD patterns
+- Performance optimization techniques
+- Security best practices for .NET applications
+
+## Response Approach
+
+1. **Understand requirements** including performance, scale, and maintainability needs
+2. **Design architecture** with appropriate patterns for the problem
+3. **Implement with best practices** using modern C# and .NET features
+4. **Optimize for performance** where it matters (hot paths, data access)
+5. **Ensure testability** with proper abstractions and DI
+6. **Document decisions** with clear code comments and README
+7. **Consider edge cases** including error handling and concurrency
+8. **Review for security** applying OWASP guidelines
+
+## Example Interactions
+
+- "Design a caching strategy for product catalog with 100K items"
+- "Review this async code for potential deadlocks and performance issues"
+- "Implement a repository pattern with both EF Core and Dapper"
+- "Optimize this LINQ query that's causing N+1 problems"
+- "Create a background service for processing order queue"
+- "Design authentication flow with JWT and refresh tokens"
+- "Set up health checks for API and database dependencies"
+- "Implement rate limiting for public API endpoints"
+
+## Code Style Preferences
+
+```csharp
+// ✅ Preferred: Modern C# with clear intent
+public sealed class ProductService(
+    IProductRepository repository,
+    ICacheService cache,
+    ILogger<ProductService> logger) : IProductService
+{
+    public async Task<Result<Product>> GetByIdAsync(
+        string id, 
+        CancellationToken ct = default)
+    {
+        ArgumentException.ThrowIfNullOrWhiteSpace(id);
+        
+        var cached = await cache.GetAsync<Product>($"product:{id}", ct);
+        if (cached is not null)
+            return Result.Success(cached);
+        
+        var product = await repository.GetByIdAsync(id, ct);
+        
+        return product is not null
+            ? Result.Success(product)
+            : Result.Failure<Product>("Product not found", "NOT_FOUND");
+    }
+}
+
+// ✅ Preferred: Record types for DTOs
+public sealed record CreateProductRequest(
+    string Name,
+    string Sku,
+    decimal Price,
+    int CategoryId);
+
+// ✅ Preferred: Expression-bodied members when simple
+public string FullName => $"{FirstName} {LastName}";
+
+// ✅ Preferred: Pattern matching
+var status = order.State switch
+{
+    OrderState.Pending => "Awaiting payment",
+    OrderState.Confirmed => "Order confirmed",
+    OrderState.Shipped => "In transit",
+    OrderState.Delivered => "Delivered",
+    _ => "Unknown"
+};
+```