skill-library-mcp 1.0.0

package/skills/zoho-crm-automation/SKILL.md

@@ -0,0 +1,206 @@
+---
+name: zoho-crm-automation
+description: "Automate Zoho CRM tasks via Rube MCP (Composio): create/update records, search contacts, manage leads, and convert leads. Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Zoho CRM Automation via Rube MCP
+
+Automate Zoho CRM operations through Composio's Zoho toolkit via Rube MCP.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Zoho CRM connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `zoho`
+- 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 `zoho`
+3. If connection is not ACTIVE, follow the returned auth link to complete Zoho OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Search and Retrieve Records
+
+**When to use**: User wants to find specific CRM records by criteria
+
+**Tool sequence**:
+1. `ZOHO_LIST_MODULES` - List available CRM modules [Prerequisite]
+2. `ZOHO_GET_MODULE_FIELDS` - Get field definitions for a module [Optional]
+3. `ZOHO_SEARCH_ZOHO_RECORDS` - Search records by criteria [Required]
+4. `ZOHO_GET_ZOHO_RECORDS` - Get records from a module [Alternative]
+
+**Key parameters**:
+- `module`: Module name (e.g., 'Leads', 'Contacts', 'Deals', 'Accounts')
+- `criteria`: Search criteria string (e.g., 'Email:equals:john@example.com')
+- `fields`: Comma-separated list of fields to return
+- `per_page`: Number of records per page
+- `page`: Page number for pagination
+
+**Pitfalls**:
+- Module names are case-sensitive (e.g., 'Leads' not 'leads')
+- Search criteria uses specific syntax: 'Field:operator:value'
+- Supported operators: equals, starts_with, contains, not_equal, greater_than, less_than
+- Complex criteria use parentheses and AND/OR: '(Email:equals:john@example.com)AND(Last_Name:equals:Doe)'
+- GET_ZOHO_RECORDS returns all records with optional filtering; SEARCH is for targeted lookups
+
+### 2. Create Records
+
+**When to use**: User wants to add new leads, contacts, deals, or other CRM records
+
+**Tool sequence**:
+1. `ZOHO_GET_MODULE_FIELDS` - Get required fields for the module [Prerequisite]
+2. `ZOHO_CREATE_ZOHO_RECORD` - Create a new record [Required]
+
+**Key parameters**:
+- `module`: Target module name (e.g., 'Leads', 'Contacts')
+- `data`: Record data object with field-value pairs
+- Required fields vary by module (e.g., Last_Name for Contacts)
+
+**Pitfalls**:
+- Each module has mandatory fields; use GET_MODULE_FIELDS to identify them
+- Field names use underscores (e.g., 'Last_Name', 'Email', 'Phone')
+- Lookup fields require the related record ID, not the name
+- Date fields must use 'yyyy-MM-dd' format
+- Creating duplicates is allowed unless duplicate check rules are configured
+
+### 3. Update Records
+
+**When to use**: User wants to modify existing CRM records
+
+**Tool sequence**:
+1. `ZOHO_SEARCH_ZOHO_RECORDS` - Find the record to update [Prerequisite]
+2. `ZOHO_UPDATE_ZOHO_RECORD` - Update the record [Required]
+
+**Key parameters**:
+- `module`: Module name
+- `record_id`: ID of the record to update
+- `data`: Object with fields to update (only changed fields needed)
+
+**Pitfalls**:
+- record_id must be the Zoho record ID (numeric string)
+- Only provide fields that need to change; other fields are preserved
+- Read-only and system fields cannot be updated
+- Lookup field updates require the related record ID
+
+### 4. Convert Leads
+
+**When to use**: User wants to convert a lead into a contact, account, and/or deal
+
+**Tool sequence**:
+1. `ZOHO_SEARCH_ZOHO_RECORDS` - Find the lead to convert [Prerequisite]
+2. `ZOHO_CONVERT_ZOHO_LEAD` - Convert the lead [Required]
+
+**Key parameters**:
+- `lead_id`: ID of the lead to convert
+- `deal`: Deal details if creating a deal during conversion
+- `account`: Account details for the conversion
+- `contact`: Contact details for the conversion
+
+**Pitfalls**:
+- Lead conversion is irreversible; the lead record is removed from the Leads module
+- Conversion can create up to three records: Contact, Account, and Deal
+- Existing account matching may occur based on company name
+- Custom field mappings between Lead and Contact/Account/Deal modules affect the outcome
+
+### 5. Manage Tags and Related Records
+
+**When to use**: User wants to tag records or manage relationships between records
+
+**Tool sequence**:
+1. `ZOHO_CREATE_ZOHO_TAG` - Create a new tag [Optional]
+2. `ZOHO_UPDATE_RELATED_RECORDS` - Update related/linked records [Optional]
+
+**Key parameters**:
+- `module`: Module for the tag
+- `tag_name`: Name of the tag
+- `record_id`: Parent record ID (for related records)
+- `related_module`: Module of the related record
+- `data`: Related record data to update
+
+**Pitfalls**:
+- Tags are module-specific; a tag created for Leads is not available in Contacts
+- Related records require both the parent record ID and the related module
+- Tag names must be unique within a module
+- Bulk tag operations may hit rate limits
+
+## Common Patterns
+
+### Module and Field Discovery
+
+```
+1. Call ZOHO_LIST_MODULES to get all available modules
+2. Call ZOHO_GET_MODULE_FIELDS with module name
+3. Identify required fields, field types, and picklist values
+4. Use field API names (not display labels) in data objects
+```
+
+### Search Criteria Syntax
+
+**Simple search**:
+```
+criteria: '(Email:equals:john@example.com)'
+```
+
+**Combined criteria**:
+```
+criteria: '((Last_Name:equals:Doe)AND(Email:contains:example.com))'
+```
+
+**Supported operators**:
+- `equals`, `not_equal`
+- `starts_with`, `contains`
+- `greater_than`, `less_than`, `greater_equal`, `less_equal`
+- `between` (for dates/numbers)
+
+### Pagination
+
+- Set `per_page` (max 200) and `page` starting at 1
+- Check response `info.more_records` flag
+- Increment page until more_records is false
+- Total count available in response info
+
+## Known Pitfalls
+
+**Field Names**:
+- Use API names, not display labels (e.g., 'Last_Name' not 'Last Name')
+- Custom fields have API names like 'Custom_Field1' or user-defined names
+- Picklist values must match exactly (case-sensitive)
+
+**Rate Limits**:
+- API call limits depend on your Zoho CRM plan
+- Free plan: 5000 API calls/day; Enterprise: 25000+/day
+- Implement delays between bulk operations
+- Monitor 429 responses and respect rate limit headers
+
+**Data Formats**:
+- Dates: 'yyyy-MM-dd' format
+- DateTime: 'yyyy-MM-ddTHH:mm:ss+HH:mm' format
+- Currency: Numeric values without formatting
+- Phone: String values (no specific format enforced)
+
+**Module Access**:
+- Access depends on user role and profile permissions
+- Some modules may be hidden or restricted in your CRM setup
+- Custom modules have custom API names
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| List modules | ZOHO_LIST_MODULES | (none) |
+| Get module fields | ZOHO_GET_MODULE_FIELDS | module |
+| Search records | ZOHO_SEARCH_ZOHO_RECORDS | module, criteria |
+| Get records | ZOHO_GET_ZOHO_RECORDS | module, fields, per_page, page |
+| Create record | ZOHO_CREATE_ZOHO_RECORD | module, data |
+| Update record | ZOHO_UPDATE_ZOHO_RECORD | module, record_id, data |
+| Convert lead | ZOHO_CONVERT_ZOHO_LEAD | lead_id, deal, account, contact |
+| Create tag | ZOHO_CREATE_ZOHO_TAG | module, tag_name |
+| Update related records | ZOHO_UPDATE_RELATED_RECORDS | module, record_id, related_module, data |

package/skills/zoom-automation/SKILL.md

@@ -0,0 +1,217 @@
+---
+name: zoom-automation
+description: "Automate Zoom meeting creation, management, recordings, webinars, and participant tracking via Rube MCP (Composio). Always search tools first for current schemas."
+requires:
+  mcp: [rube]
+---
+
+# Zoom Automation via Rube MCP
+
+Automate Zoom operations including meeting scheduling, webinar management, cloud recording retrieval, participant tracking, and usage reporting through Composio's Zoom toolkit.
+
+## Prerequisites
+
+- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
+- Active Zoom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `zoom`
+- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
+- Most features require a paid Zoom account (Pro plan or higher)
+
+## 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 `zoom`
+3. If connection is not ACTIVE, follow the returned auth link to complete Zoom OAuth
+4. Confirm connection status shows ACTIVE before running any workflows
+
+## Core Workflows
+
+### 1. Create and Schedule Meetings
+
+**When to use**: User wants to create a new Zoom meeting with specific time, duration, and settings
+
+**Tool sequence**:
+1. `ZOOM_GET_USER` - Verify authenticated user and check license type [Prerequisite]
+2. `ZOOM_CREATE_A_MEETING` - Create the meeting with topic, time, duration, and settings [Required]
+3. `ZOOM_GET_A_MEETING` - Retrieve full meeting details including join_url [Optional]
+4. `ZOOM_UPDATE_A_MEETING` - Modify meeting settings or reschedule [Optional]
+5. `ZOOM_ADD_A_MEETING_REGISTRANT` - Register participants for registration-enabled meetings [Optional]
+
+**Key parameters**:
+- `userId`: Always use `"me"` for user-level apps
+- `topic`: Meeting subject line
+- `type`: `1` (instant), `2` (scheduled), `3` (recurring no fixed time), `8` (recurring fixed time)
+- `start_time`: ISO 8601 format (`yyyy-MM-ddTHH:mm:ssZ` for UTC or `yyyy-MM-ddTHH:mm:ss` with timezone field)
+- `timezone`: Timezone ID (e.g., `"America/New_York"`)
+- `duration`: Duration in minutes
+- `settings__auto_recording`: `"none"`, `"local"`, or `"cloud"`
+- `settings__waiting_room`: Boolean to enable waiting room
+- `settings__join_before_host`: Boolean (disabled when waiting room is enabled)
+- `settings__meeting_invitees`: Array of invitee objects with email addresses
+
+**Pitfalls**:
+- `start_time` must be in the future; Zoom stores and returns times in UTC regardless of input timezone
+- If no `start_time` is set for type `2`, it becomes an instant meeting that expires after 30 days
+- The `join_url` for participants and `start_url` for host come from the create response - persist these
+- `start_url` expires in 2 hours (or 90 days for `custCreate` users)
+- Meeting creation is rate-limited to 100 requests/day
+- Setting names use double underscores for nesting (e.g., `settings__host_video`)
+
+### 2. List and Manage Meetings
+
+**When to use**: User wants to view upcoming, live, or past meetings
+
+**Tool sequence**:
+1. `ZOOM_LIST_MEETINGS` - List meetings by type (scheduled, live, upcoming, previous) [Required]
+2. `ZOOM_GET_A_MEETING` - Get detailed info for a specific meeting [Optional]
+3. `ZOOM_UPDATE_A_MEETING` - Modify meeting details [Optional]
+
+**Key parameters**:
+- `userId`: Use `"me"` for authenticated user
+- `type`: `"scheduled"` (default), `"live"`, `"upcoming"`, `"upcoming_meetings"`, `"previous_meetings"`
+- `page_size`: Records per page (default 30)
+- `next_page_token`: Pagination token from previous response
+- `from` / `to`: Date range filters
+
+**Pitfalls**:
+- `ZOOM_LIST_MEETINGS` excludes instant meetings and only shows unexpired scheduled meetings
+- For past meetings, use `type: "previous_meetings"`
+- Pagination: always follow `next_page_token` until empty to get complete results
+- Token expiration: `next_page_token` expires after 15 minutes
+- Meeting IDs can exceed 10 digits; store as long integers, not standard integers
+
+### 3. Manage Recordings
+
+**When to use**: User wants to list, retrieve, or delete cloud recordings
+
+**Tool sequence**:
+1. `ZOOM_LIST_ALL_RECORDINGS` - List all cloud recordings for a user within a date range [Required]
+2. `ZOOM_GET_MEETING_RECORDINGS` - Get recordings for a specific meeting [Optional]
+3. `ZOOM_DELETE_MEETING_RECORDINGS` - Move recordings to trash or permanently delete [Optional]
+4. `ZOOM_LIST_ARCHIVED_FILES` - List archived meeting/webinar files [Optional]
+
+**Key parameters**:
+- `userId`: Use `"me"` for authenticated user
+- `from` / `to`: Date range in `yyyy-mm-dd` format (max 1 month range)
+- `meetingId`: Meeting ID or UUID for specific recording retrieval
+- `action`: `"trash"` (recoverable) or `"delete"` (permanent) for deletion
+- `include_fields`: Set to `"download_access_token"` to get JWT for downloading recordings
+- `trash`: Set `true` to list recordings from trash
+
+**Pitfalls**:
+- Date range maximum is 1 month; API auto-adjusts `from` if range exceeds this
+- Cloud Recording must be enabled on the account
+- UUIDs starting with `/` or containing `//` must be double URL-encoded
+- `ZOOM_DELETE_MEETING_RECORDINGS` defaults to `"trash"` action (recoverable); `"delete"` is permanent
+- Download URLs require the OAuth token in the Authorization header for passcode-protected recordings
+- Requires Pro plan or higher
+
+### 4. Get Meeting Participants and Reports
+
+**When to use**: User wants to see who attended a past meeting or get usage statistics
+
+**Tool sequence**:
+1. `ZOOM_GET_PAST_MEETING_PARTICIPANTS` - List attendees of a completed meeting [Required]
+2. `ZOOM_GET_A_MEETING` - Get meeting details and registration info for upcoming meetings [Optional]
+3. `ZOOM_GET_DAILY_USAGE_REPORT` - Get daily usage statistics (meetings, participants, minutes) [Optional]
+4. `ZOOM_GET_A_MEETING_SUMMARY` - Get AI-generated meeting summary [Optional]
+
+**Key parameters**:
+- `meetingId`: Meeting ID (latest instance) or UUID (specific occurrence)
+- `page_size`: Records per page (default 30)
+- `next_page_token`: Pagination token for large participant lists
+
+**Pitfalls**:
+- `ZOOM_GET_PAST_MEETING_PARTICIPANTS` only works for completed meetings on paid plans
+- Solo meetings (no other participants) return empty results
+- UUID encoding: UUIDs starting with `/` or containing `//` must be double-encoded
+- Always paginate with `next_page_token` until empty to avoid dropping attendees
+- `ZOOM_GET_A_MEETING_SUMMARY` requires a paid plan with AI Companion enabled; free accounts get 400 errors
+- `ZOOM_GET_DAILY_USAGE_REPORT` has a Heavy rate limit; avoid frequent calls
+
+### 5. Manage Webinars
+
+**When to use**: User wants to list webinars or register participants for webinars
+
+**Tool sequence**:
+1. `ZOOM_LIST_WEBINARS` - List scheduled or upcoming webinars [Required]
+2. `ZOOM_GET_A_WEBINAR` - Get detailed webinar information [Optional]
+3. `ZOOM_ADD_A_WEBINAR_REGISTRANT` - Register a participant for a webinar [Optional]
+
+**Key parameters**:
+- `userId`: Use `"me"` for authenticated user
+- `type`: `"scheduled"` (default) or `"upcoming"`
+- `page_size`: Records per page (default 30)
+- `next_page_token`: Pagination token
+
+**Pitfalls**:
+- Webinar features require Pro plan or higher with Webinar add-on
+- Free/basic accounts cannot use webinar tools
+- Only shows unexpired webinars
+- Registration must be enabled on the webinar for `ZOOM_ADD_A_WEBINAR_REGISTRANT` to work
+
+## Common Patterns
+
+### ID Resolution
+- **User ID**: Always use `"me"` for user-level apps to refer to the authenticated user
+- **Meeting ID**: Numeric ID (store as long integer); use for latest instance
+- **Meeting UUID**: Use for specific occurrence of recurring meetings; double-encode if starts with `/` or contains `//`
+- **Occurrence ID**: Use with recurring meetings to target a specific occurrence
+
+### Pagination
+Most Zoom list endpoints use token-based pagination:
+- Follow `next_page_token` until it is empty or missing
+- Token expires after 15 minutes
+- Set explicit `page_size` (default 30, varies by endpoint)
+- Do not use `page_number` (deprecated on many endpoints)
+
+### Time Handling
+- Zoom stores all times in UTC internally
+- Provide `timezone` field alongside `start_time` for local time input
+- Use ISO 8601 format: `yyyy-MM-ddTHH:mm:ssZ` (UTC) or `yyyy-MM-ddTHH:mm:ss` (with timezone field)
+- Date-only fields use `yyyy-mm-dd` format
+
+## Known Pitfalls
+
+### Plan Requirements
+- Most recording and participant features require Pro plan or higher
+- Webinar features require Webinar add-on
+- AI meeting summaries require AI Companion feature enabled
+- Archived files require "Meeting and Webinar Archiving" enabled by Zoom Support
+
+### Rate Limits
+- Meeting creation: 100 requests/day, 100 updates per meeting in 24 hours
+- `ZOOM_GET_PAST_MEETING_PARTICIPANTS`: Moderate throttle; add delays for batch processing
+- `ZOOM_GET_DAILY_USAGE_REPORT`: Heavy rate limit
+- `ZOOM_GET_A_MEETING`, `ZOOM_GET_MEETING_RECORDINGS`: Light rate limit
+- `ZOOM_LIST_MEETINGS`, `ZOOM_LIST_ALL_RECORDINGS`: Medium rate limit
+
+### Parameter Quirks
+- Nested settings use double underscore notation (e.g., `settings__waiting_room`)
+- `start_url` expires in 2 hours; renew via API if needed
+- `join_before_host` is automatically disabled when `waiting_room` is `true`
+- Recurring meeting fields (`recurrence__*`) only apply to type `3` and `8`
+- `password` field has max 10 characters with alphanumeric and `@`, `-`, `_`, `*` only
+
+## Quick Reference
+
+| Task | Tool Slug | Key Params |
+|------|-----------|------------|
+| Create meeting | `ZOOM_CREATE_A_MEETING` | `userId`, `topic`, `start_time`, `type` |
+| Get meeting details | `ZOOM_GET_A_MEETING` | `meetingId` |
+| Update meeting | `ZOOM_UPDATE_A_MEETING` | `meetingId`, fields to update |
+| List meetings | `ZOOM_LIST_MEETINGS` | `userId`, `type`, `page_size` |
+| Get user info | `ZOOM_GET_USER` | `userId` |
+| List recordings | `ZOOM_LIST_ALL_RECORDINGS` | `userId`, `from`, `to` |
+| Get recording | `ZOOM_GET_MEETING_RECORDINGS` | `meetingId` |
+| Delete recording | `ZOOM_DELETE_MEETING_RECORDINGS` | `meetingId`, `action` |
+| Past participants | `ZOOM_GET_PAST_MEETING_PARTICIPANTS` | `meetingId`, `page_size` |
+| Daily usage report | `ZOOM_GET_DAILY_USAGE_REPORT` | date params |
+| Meeting summary | `ZOOM_GET_A_MEETING_SUMMARY` | `meetingId` |
+| List webinars | `ZOOM_LIST_WEBINARS` | `userId`, `type` |
+| Get webinar | `ZOOM_GET_A_WEBINAR` | webinar ID |
+| Register for meeting | `ZOOM_ADD_A_MEETING_REGISTRANT` | `meetingId`, participant details |
+| Register for webinar | `ZOOM_ADD_A_WEBINAR_REGISTRANT` | webinar ID, participant details |
+| List archived files | `ZOOM_LIST_ARCHIVED_FILES` | `from`, `to` |

package/src/dedup.ts

@@ -0,0 +1,132 @@
+import { readdir, readFile, access } from "node:fs/promises";
+import { join } from "node:path";
+import { createHash } from "node:crypto";
+import { parse as parseYaml } from "yaml";
+
+interface SkillMeta {
+  dirName: string;
+  name: string;
+  description: string;
+}
+
+export interface DuplicateReport {
+  exactDuplicates: SkillMeta[][];
+  nearDuplicates: { pair: [SkillMeta, SkillMeta]; similarity: number }[];
+}
+
+function parseFrontmatter(content: string): { name: string; description: string } | null {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  try {
+    const parsed = parseYaml(match[1]);
+    if (!parsed || typeof parsed.name !== "string") return null;
+    return {
+      name: parsed.name,
+      description: typeof parsed.description === "string" ? parsed.description.trim() : "",
+    };
+  } catch {
+    return null;
+  }
+}
+
+function jaccardSimilarity(a: string, b: string): number {
+  const wordsA = new Set(a.toLowerCase().split(/\s+/).filter(Boolean));
+  const wordsB = new Set(b.toLowerCase().split(/\s+/).filter(Boolean));
+  if (wordsA.size === 0 && wordsB.size === 0) return 1;
+  if (wordsA.size === 0 || wordsB.size === 0) return 0;
+
+  let intersection = 0;
+  for (const w of wordsA) {
+    if (wordsB.has(w)) intersection++;
+  }
+  const union = wordsA.size + wordsB.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+
+export async function findDuplicates(skillsDir: string): Promise<DuplicateReport> {
+  const skills: SkillMeta[] = [];
+  let dirs: string[];
+
+  try {
+    dirs = await readdir(skillsDir);
+  } catch {
+    return { exactDuplicates: [], nearDuplicates: [] };
+  }
+
+  for (const dirName of dirs) {
+    const skillPath = join(skillsDir, dirName, "SKILL.md");
+    try {
+      await access(skillPath);
+    } catch {
+      continue;
+    }
+
+    const content = await readFile(skillPath, "utf-8");
+    const fm = parseFrontmatter(content);
+    if (!fm) continue;
+
+    skills.push({ dirName, name: fm.name, description: fm.description });
+  }
+
+  // Find exact duplicates: identical name + description hash
+  const hashMap = new Map<string, SkillMeta[]>();
+  for (const skill of skills) {
+    const hash = createHash("sha256")
+      .update(`${skill.name}\n${skill.description}`)
+      .digest("hex");
+    const group = hashMap.get(hash) ?? [];
+    group.push(skill);
+    hashMap.set(hash, group);
+  }
+
+  const exactDuplicates = [...hashMap.values()].filter((group) => group.length > 1);
+
+  // Find near duplicates: Jaccard word similarity > 0.8 on descriptions
+  const nearDuplicates: DuplicateReport["nearDuplicates"] = [];
+  for (let i = 0; i < skills.length; i++) {
+    for (let j = i + 1; j < skills.length; j++) {
+      const a = skills[i];
+      const b = skills[j];
+      // Skip exact dupes (already reported)
+      if (a.name === b.name && a.description === b.description) continue;
+      // Only check if descriptions are non-empty
+      if (!a.description || !b.description) continue;
+
+      const sim = jaccardSimilarity(a.description, b.description);
+      if (sim > 0.8) {
+        nearDuplicates.push({ pair: [a, b], similarity: Math.round(sim * 100) / 100 });
+      }
+    }
+  }
+
+  return { exactDuplicates, nearDuplicates };
+}
+
+// CLI entrypoint
+if (process.argv[1] && (process.argv[1].endsWith("dedup.ts") || process.argv[1].endsWith("dedup.js"))) {
+  const dir = process.argv[2] || join(process.cwd(), "skills");
+
+  findDuplicates(dir).then((report) => {
+    if (report.exactDuplicates.length > 0) {
+      console.log(`\n❌ Found ${report.exactDuplicates.length} exact duplicate group(s):\n`);
+      for (const group of report.exactDuplicates) {
+        console.log(`  Name: "${group[0].name}"`);
+        console.log(`  Dirs: ${group.map((s) => s.dirName).join(", ")}\n`);
+      }
+    } else {
+      console.log("\n✅ No exact duplicates found.\n");
+    }
+
+    if (report.nearDuplicates.length > 0) {
+      console.log(`⚠️  Found ${report.nearDuplicates.length} near-duplicate pair(s):\n`);
+      for (const { pair, similarity } of report.nearDuplicates) {
+        console.log(`  ${pair[0].dirName} ↔ ${pair[1].dirName} (${(similarity * 100).toFixed(0)}% similar)`);
+      }
+      console.log();
+    } else {
+      console.log("✅ No near-duplicates found.\n");
+    }
+
+    process.exit(report.exactDuplicates.length > 0 ? 1 : 0);
+  });
+}

package/src/index.ts

@@ -0,0 +1,26 @@
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { fileURLToPath } from "node:url";
+import { dirname, join } from "node:path";
+import { buildIndex } from "./skill-index.js";
+import { createServer } from "./server.js";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Skills directory is at the project root, sibling to dist/
+const skillsDir = join(__dirname, "..", "skills");
+
+async function main() {
+  const index = await buildIndex(skillsDir);
+  console.error(`[skill-library] Indexed ${index.entries.length} skills from ${skillsDir}`);
+
+  const server = createServer(index, skillsDir);
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("[skill-library] MCP server running on stdio");
+}
+
+main().catch((err) => {
+  console.error("[skill-library] Fatal error:", err);
+  process.exit(1);
+});

package/src/loader.ts

@@ -0,0 +1,33 @@
+import { readFile, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import type { SkillEntry } from "./types.js";
+
+export async function loadSkill(
+  entry: SkillEntry,
+  skillsDir: string,
+  includeResources: boolean = false,
+): Promise<string> {
+  const skillDir = join(skillsDir, entry.dirName);
+  const skillPath = join(skillDir, "SKILL.md");
+  const absoluteSkillDir = resolve(skillDir);
+  let content = `> **Skill directory**: ${absoluteSkillDir}\n> Resolve relative paths (scripts/, resources/, etc.) against this directory.\n\n`;
+  content += await readFile(skillPath, "utf-8");
+
+  if (includeResources && entry.hasResources) {
+    const resourceDir = join(skillsDir, entry.dirName, "resources");
+
+    try {
+      const files = await readdir(resourceDir);
+      const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+
+      for (const file of mdFiles) {
+        const resourceContent = await readFile(join(resourceDir, file), "utf-8");
+        content += `\n\n---\n\n# Resource: ${file}\n\n${resourceContent}`;
+      }
+    } catch {
+      // Resources directory not accessible
+    }
+  }
+
+  return content;
+}