claude-skill-lord 1.5.0

package/skills/tier-2/mcp-management/scripts/dist/analyze-tools.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+/**
+ * Tool Analyzer - Intelligently selects relevant MCP tools for tasks
+ */
+/**
+ * Analyze tools and return those relevant to the task
+ */
+export function analyzeToolsForTask(tools, taskDescription) {
+    const keywords = extractKeywords(taskDescription);
+    const scoredTools = tools.map(tool => ({
+        tool,
+        score: calculateRelevanceScore(tool, keywords, taskDescription),
+        reasons: explainScore(tool, keywords, taskDescription)
+    }));
+    // Sort by score descending
+    scoredTools.sort((a, b) => b.score - a.score);
+    // Filter tools with score above threshold
+    const threshold = 0.3;
+    const relevant = scoredTools.filter(st => st.score > threshold);
+    return {
+        relevantTools: relevant.map(st => st.tool),
+        reasoning: relevant.map(st => `${st.tool.name} (${st.tool.serverName}): ${st.reasons.join('; ')}`),
+        confidence: relevant.length > 0
+            ? relevant[0].score
+            : 0
+    };
+}
+function extractKeywords(text) {
+    const stopWords = new Set([
+        'the', 'a', 'an', 'and', 'or', 'but', 'in', 'on', 'at',
+        'to', 'for', 'of', 'with', 'by', 'from', 'as', 'is', 'was', 'are'
+    ]);
+    return text
+        .toLowerCase()
+        .split(/\W+/)
+        .filter(word => word.length > 2 && !stopWords.has(word));
+}
+function calculateRelevanceScore(tool, keywords, taskDescription) {
+    let score = 0;
+    const toolText = `${tool.name} ${tool.description}`.toLowerCase();
+    // Keyword matching
+    for (const keyword of keywords) {
+        if (toolText.includes(keyword)) {
+            score += 0.2;
+        }
+    }
+    // Exact phrase matching
+    const taskLower = taskDescription.toLowerCase();
+    if (toolText.includes(taskLower) || taskLower.includes(tool.name.toLowerCase())) {
+        score += 0.5;
+    }
+    // Schema complexity bonus (more params = more specialized)
+    if (tool.inputSchema?.properties) {
+        const paramCount = Object.keys(tool.inputSchema.properties).length;
+        score += Math.min(paramCount * 0.05, 0.3);
+    }
+    return Math.min(score, 1.0);
+}
+function explainScore(tool, keywords, taskDescription) {
+    const reasons = [];
+    const toolText = `${tool.name} ${tool.description}`.toLowerCase();
+    const matchedKeywords = keywords.filter(k => toolText.includes(k));
+    if (matchedKeywords.length > 0) {
+        reasons.push(`matches keywords: ${matchedKeywords.join(', ')}`);
+    }
+    if (tool.description) {
+        reasons.push(`description: ${tool.description.slice(0, 100)}`);
+    }
+    return reasons;
+}

package/skills/tier-2/mcp-management/scripts/dist/cli.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+/**
+ * MCP Management CLI - Command-line interface for MCP operations
+ */
+import { MCPClientManager } from './mcp-client.js';
+import { writeFileSync, mkdirSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+async function main() {
+    const args = process.argv.slice(2);
+    const command = args[0];
+    const manager = new MCPClientManager();
+    try {
+        // Load config
+        await manager.loadConfig();
+        console.log('✓ Config loaded');
+        // Connect to all servers
+        await manager.connectAll();
+        console.log('✓ Connected to all MCP servers\n');
+        switch (command) {
+            case 'list-tools':
+                await listTools(manager);
+                break;
+            case 'list-prompts':
+                await listPrompts(manager);
+                break;
+            case 'list-resources':
+                await listResources(manager);
+                break;
+            case 'call-tool':
+                await callTool(manager, args[1], args[2], args[3]);
+                break;
+            default:
+                printUsage();
+        }
+        await manager.cleanup();
+    }
+    catch (error) {
+        console.error('Error:', error);
+        process.exit(1);
+    }
+}
+async function listTools(manager) {
+    const tools = await manager.getAllTools();
+    console.log(`Found ${tools.length} tools:\n`);
+    for (const tool of tools) {
+        console.log(`📦 ${tool.serverName} / ${tool.name}`);
+        console.log(`   ${tool.description}`);
+        if (tool.inputSchema?.properties) {
+            console.log(`   Parameters: ${Object.keys(tool.inputSchema.properties).join(', ')}`);
+        }
+        console.log('');
+    }
+    // Save tools to JSON file
+    const assetsDir = join(__dirname, '..', 'assets');
+    const toolsPath = join(assetsDir, 'tools.json');
+    try {
+        mkdirSync(assetsDir, { recursive: true });
+        writeFileSync(toolsPath, JSON.stringify(tools, null, 2));
+        console.log(`\n✓ Tools saved to ${toolsPath}`);
+    }
+    catch (error) {
+        console.error(`\n✗ Failed to save tools: ${error}`);
+    }
+}
+async function listPrompts(manager) {
+    const prompts = await manager.getAllPrompts();
+    console.log(`Found ${prompts.length} prompts:\n`);
+    for (const prompt of prompts) {
+        console.log(`💬 ${prompt.serverName} / ${prompt.name}`);
+        console.log(`   ${prompt.description}`);
+        if (prompt.arguments && prompt.arguments.length > 0) {
+            console.log(`   Arguments: ${prompt.arguments.map((a) => a.name).join(', ')}`);
+        }
+        console.log('');
+    }
+}
+async function listResources(manager) {
+    const resources = await manager.getAllResources();
+    console.log(`Found ${resources.length} resources:\n`);
+    for (const resource of resources) {
+        console.log(`📄 ${resource.serverName} / ${resource.name}`);
+        console.log(`   URI: ${resource.uri}`);
+        if (resource.description) {
+            console.log(`   ${resource.description}`);
+        }
+        if (resource.mimeType) {
+            console.log(`   Type: ${resource.mimeType}`);
+        }
+        console.log('');
+    }
+}
+async function callTool(manager, serverName, toolName, argsJson) {
+    if (!serverName || !toolName || !argsJson) {
+        console.error('Usage: cli.ts call-tool <server> <tool> <json-args>');
+        process.exit(1);
+    }
+    const args = JSON.parse(argsJson);
+    console.log(`Calling ${serverName}/${toolName}...`);
+    const result = await manager.callTool(serverName, toolName, args);
+    console.log('\nResult:');
+    console.log(JSON.stringify(result, null, 2));
+}
+function printUsage() {
+    console.log(`
+MCP Management CLI
+
+Usage:
+  cli.ts <command> [options]
+
+Commands:
+  list-tools                        List all tools and save to assets/tools.json
+  list-prompts                      List all prompts from all MCP servers
+  list-resources                    List all resources from all MCP servers
+  call-tool <server> <tool> <json>  Call a specific tool
+
+Examples:
+  cli.ts list-tools
+  cli.ts call-tool memory create_entities '{"entities":[{"name":"Alice","entityType":"person"}]}'
+  cli.ts call-tool human-mcp playwright_screenshot_fullpage '{"url":"https://example.com"}'
+
+Note: Tool analysis is done by the LLM reading assets/tools.json directly.
+  `);
+}
+main();

package/skills/tier-2/mcp-management/scripts/dist/mcp-client.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+/**
+ * MCP Client - Core client for interacting with MCP servers
+ */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+export class MCPClientManager {
+    config = null;
+    clients = new Map();
+    async loadConfig(configPath = '.claude/.mcp.json') {
+        const fullPath = resolve(process.cwd(), configPath);
+        const content = await readFile(fullPath, 'utf-8');
+        const config = JSON.parse(content);
+        this.config = config;
+        return config;
+    }
+    async connectToServer(serverName) {
+        if (!this.config?.mcpServers[serverName]) {
+            throw new Error(`Server ${serverName} not found in config`);
+        }
+        const serverConfig = this.config.mcpServers[serverName];
+        const transport = new StdioClientTransport({
+            command: serverConfig.command,
+            args: serverConfig.args,
+            env: serverConfig.env
+        });
+        const client = new Client({
+            name: `mcp-manager-${serverName}`,
+            version: '1.0.0'
+        }, { capabilities: {} });
+        await client.connect(transport);
+        this.clients.set(serverName, client);
+        return client;
+    }
+    async connectAll() {
+        if (!this.config) {
+            throw new Error('Config not loaded. Call loadConfig() first.');
+        }
+        const connections = Object.keys(this.config.mcpServers).map(name => this.connectToServer(name));
+        await Promise.all(connections);
+    }
+    async getAllTools() {
+        const allTools = [];
+        for (const [serverName, client] of this.clients.entries()) {
+            const response = await client.listTools({}, { timeout: 300000 });
+            for (const tool of response.tools) {
+                allTools.push({
+                    serverName,
+                    name: tool.name,
+                    description: tool.description || '',
+                    inputSchema: tool.inputSchema,
+                    outputSchema: tool.outputSchema
+                });
+            }
+        }
+        return allTools;
+    }
+    async getAllPrompts() {
+        const allPrompts = [];
+        for (const [serverName, client] of this.clients.entries()) {
+            const response = await client.listPrompts({}, { timeout: 300000 });
+            for (const prompt of response.prompts) {
+                allPrompts.push({
+                    serverName,
+                    name: prompt.name,
+                    description: prompt.description || '',
+                    arguments: prompt.arguments
+                });
+            }
+        }
+        return allPrompts;
+    }
+    async getAllResources() {
+        const allResources = [];
+        for (const [serverName, client] of this.clients.entries()) {
+            const response = await client.listResources({}, { timeout: 300000 });
+            for (const resource of response.resources) {
+                allResources.push({
+                    serverName,
+                    uri: resource.uri,
+                    name: resource.name,
+                    description: resource.description,
+                    mimeType: resource.mimeType
+                });
+            }
+        }
+        return allResources;
+    }
+    async callTool(serverName, toolName, args) {
+        const client = this.clients.get(serverName);
+        if (!client)
+            throw new Error(`Not connected to server: ${serverName}`);
+        return await client.callTool({ name: toolName, arguments: args }, undefined, { timeout: 300000 });
+    }
+    async getPrompt(serverName, promptName, args) {
+        const client = this.clients.get(serverName);
+        if (!client)
+            throw new Error(`Not connected to server: ${serverName}`);
+        return await client.getPrompt({ name: promptName, arguments: args }, { timeout: 300000 });
+    }
+    async readResource(serverName, uri) {
+        const client = this.clients.get(serverName);
+        if (!client)
+            throw new Error(`Not connected to server: ${serverName}`);
+        return await client.readResource({ uri }, { timeout: 300000 });
+    }
+    async cleanup() {
+        for (const client of this.clients.values()) {
+            await client.close();
+        }
+        this.clients.clear();
+    }
+}

package/skills/tier-2/mcp-management/scripts/mcp-client.ts

@@ -0,0 +1,230 @@
+#!/usr/bin/env node
+/**
+ * MCP Client - Core client for interacting with MCP servers
+ */
+
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+
+interface MCPConfig {
+  mcpServers: {
+    [key: string]: {
+      command: string;
+      args: string[];
+      env?: Record<string, string>;
+    };
+  };
+}
+
+interface ToolInfo {
+  serverName: string;
+  name: string;
+  description: string;
+  inputSchema: any;
+  outputSchema?: any;
+}
+
+interface PromptInfo {
+  serverName: string;
+  name: string;
+  description: string;
+  arguments?: any[];
+}
+
+interface ResourceInfo {
+  serverName: string;
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+
+export class MCPClientManager {
+  private config: MCPConfig | null = null;
+  private clients: Map<string, Client> = new Map();
+  private transports: Map<string, StdioClientTransport> = new Map();
+
+  async loadConfig(configPath: string = '.claude/.mcp.json'): Promise<MCPConfig> {
+    const fullPath = resolve(process.cwd(), configPath);
+    const content = await readFile(fullPath, 'utf-8');
+    const config = JSON.parse(content) as MCPConfig;
+    this.config = config;
+    return config;
+  }
+
+  async connectToServer(serverName: string): Promise<Client> {
+    if (!this.config?.mcpServers[serverName]) {
+      throw new Error(`Server ${serverName} not found in config`);
+    }
+
+    const serverConfig = this.config.mcpServers[serverName];
+    const transport = new StdioClientTransport({
+      command: serverConfig.command,
+      args: serverConfig.args,
+      env: serverConfig.env
+    });
+
+    const client = new Client({
+      name: `mcp-manager-${serverName}`,
+      version: '1.0.0'
+    }, { capabilities: {} });
+
+    await client.connect(transport);
+    this.clients.set(serverName, client);
+    this.transports.set(serverName, transport); // Track transport!
+    return client;
+  }
+
+  async connectAll(): Promise<void> {
+    if (!this.config) {
+      throw new Error('Config not loaded. Call loadConfig() first.');
+    }
+
+    const serverNames = Object.keys(this.config.mcpServers);
+    console.log(`Connecting to ${serverNames.length} servers sequentially...`);
+
+    for (const serverName of serverNames) {
+      try {
+        await this.connectToServer(serverName);
+        console.log(`✓ ${serverName} connected`);
+      } catch (error) {
+        console.error(`✗ ${serverName} failed:`, error);
+        // Continue with other servers
+      }
+    }
+  }
+
+  async getAllTools(): Promise<ToolInfo[]> {
+    const allTools: ToolInfo[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        const response = await client.listTools({}, { timeout: 300000 });
+        for (const tool of response.tools) {
+          allTools.push({
+            serverName,
+            name: tool.name,
+            description: tool.description || '',
+            inputSchema: tool.inputSchema,
+            outputSchema: (tool as any).outputSchema
+          });
+        }
+      } catch (error: any) {
+        if (error?.code === -32601) {
+          console.warn(`${serverName} does not support listTools`);
+        } else {
+          console.error(`Error from ${serverName}:`, error);
+        }
+        // Continue with other servers!
+      }
+    }
+    return allTools;
+  }
+
+  async getAllPrompts(): Promise<PromptInfo[]> {
+    const allPrompts: PromptInfo[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        const response = await client.listPrompts({}, { timeout: 300000 });
+        for (const prompt of response.prompts) {
+          allPrompts.push({
+            serverName,
+            name: prompt.name,
+            description: prompt.description || '',
+            arguments: prompt.arguments
+          });
+        }
+      } catch (error: any) {
+        if (error?.code === -32601) {
+          console.warn(`${serverName} does not support listPrompts`);
+        } else {
+          console.error(`Error from ${serverName}:`, error);
+        }
+        // Continue with other servers!
+      }
+    }
+    return allPrompts;
+  }
+
+  async getAllResources(): Promise<ResourceInfo[]> {
+    const allResources: ResourceInfo[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      try {
+        const response = await client.listResources({}, { timeout: 300000 });
+        for (const resource of response.resources) {
+          allResources.push({
+            serverName,
+            uri: resource.uri,
+            name: resource.name,
+            description: resource.description,
+            mimeType: resource.mimeType
+          });
+        }
+      } catch (error: any) {
+        if (error?.code === -32601) {
+          console.warn(`${serverName} does not support listResources`);
+        } else {
+          console.error(`Error from ${serverName}:`, error);
+        }
+        // Continue with other servers!
+      }
+    }
+    return allResources;
+  }
+
+  async callTool(serverName: string, toolName: string, args: any): Promise<any> {
+    const client = this.clients.get(serverName);
+    if (!client) throw new Error(`Not connected to server: ${serverName}`);
+    return await client.callTool(
+      { name: toolName, arguments: args },
+      undefined,
+      { timeout: 300000 }
+    );
+  }
+
+  async getPrompt(serverName: string, promptName: string, args?: any): Promise<any> {
+    const client = this.clients.get(serverName);
+    if (!client) throw new Error(`Not connected to server: ${serverName}`);
+    return await client.getPrompt({ name: promptName, arguments: args }, { timeout: 300000 });
+  }
+
+  async readResource(serverName: string, uri: string): Promise<any> {
+    const client = this.clients.get(serverName);
+    if (!client) throw new Error(`Not connected to server: ${serverName}`);
+    return await client.readResource({ uri }, { timeout: 300000 });
+  }
+
+  async cleanup(): Promise<void> {
+    // Close clients with timeout
+    const cleanupPromises: Promise<void>[] = [];
+    for (const [serverName, client] of this.clients.entries()) {
+      cleanupPromises.push(
+        (async () => {
+          try {
+            await client.close();
+          } catch (error) {
+            console.warn(`Warning closing ${serverName}:`, error);
+          }
+        })()
+      );
+    }
+
+    await Promise.race([
+      Promise.all(cleanupPromises),
+      new Promise<void>((resolve) => setTimeout(resolve, 5000))
+    ]);
+
+    // CRITICAL: Close transports to kill subprocesses
+    for (const [serverName, transport] of this.transports.entries()) {
+      try {
+        await transport.close();
+      } catch (error) {
+        console.warn(`Warning closing ${serverName} transport:`, error);
+      }
+    }
+
+    this.clients.clear();
+    this.transports.clear();
+  }
+}

package/skills/tier-2/mcp-management/scripts/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "mcp-management-scripts",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "MCP client scripts for managing MCP servers",
+  "scripts": {
+    "build": "tsc",
+    "test": "node --loader ts-node/esm test.ts"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "nodemon": "^3.1.11",
+    "ts-node": "^10.9.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}

package/skills/tier-2/mcp-management/scripts/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./",
+    "resolveJsonModule": true
+  },
+  "include": ["*.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/skills/tier-2/mcp-server-patterns/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: mcp-server-patterns
+description: Build MCP servers with Node/TypeScript SDK — tools, resources, prompts, Zod validation, stdio vs Streamable HTTP. Use Context7 or official MCP docs for latest API.
+origin: ECC
+---
+
+# MCP Server Patterns
+
+The Model Context Protocol (MCP) lets AI assistants call tools, read resources, and use prompts from your server. Use this skill when building or maintaining MCP servers. The SDK API evolves; check Context7 (query-docs for "MCP") or the official MCP documentation for current method names and signatures.
+
+## When to Use
+
+Use when: implementing a new MCP server, adding tools or resources, choosing stdio vs HTTP, upgrading the SDK, or debugging MCP registration and transport issues.
+
+## How It Works
+
+### Core concepts
+
+- **Tools**: Actions the model can invoke (e.g. search, run a command). Register with `registerTool()` or `tool()` depending on SDK version.
+- **Resources**: Read-only data the model can fetch (e.g. file contents, API responses). Register with `registerResource()` or `resource()`. Handlers typically receive a `uri` argument.
+- **Prompts**: Reusable, parameterised prompt templates the client can surface (e.g. in Claude Desktop). Register with `registerPrompt()` or equivalent.
+- **Transport**: stdio for local clients (e.g. Claude Desktop); Streamable HTTP is preferred for remote (Cursor, cloud). Legacy HTTP/SSE is for backward compatibility.
+
+The Node/TypeScript SDK may expose `tool()` / `resource()` or `registerTool()` / `registerResource()`; the official SDK has changed over time. Always verify against the current [MCP docs](https://modelcontextprotocol.io) or Context7.
+
+### Connecting with stdio
+
+For local clients, create a stdio transport and pass it to your server’s connect method. The exact API varies by SDK version (e.g. constructor vs factory). See the official MCP documentation or query Context7 for "MCP stdio server" for the current pattern.
+
+Keep server logic (tools + resources) independent of transport so you can plug in stdio or HTTP in the entrypoint.
+
+### Remote (Streamable HTTP)
+
+For Cursor, cloud, or other remote clients, use **Streamable HTTP** (single MCP HTTP endpoint per current spec). Support legacy HTTP/SSE only when backward compatibility is required.
+
+## Examples
+
+### Install and server setup
+
+```bash
+npm install @modelcontextprotocol/sdk zod
+```
+
+```typescript
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+
+const server = new McpServer({ name: "my-server", version: "1.0.0" });
+```
+
+Register tools and resources using the API your SDK version provides: some versions use `server.tool(name, description, schema, handler)` (positional args), others use `server.tool({ name, description, inputSchema }, handler)` or `registerTool()`. Same for resources — include a `uri` in the handler when the API provides it. Check the official MCP docs or Context7 for the current `@modelcontextprotocol/sdk` signatures to avoid copy-paste errors.
+
+Use **Zod** (or the SDK’s preferred schema format) for input validation.
+
+## Best Practices
+
+- **Schema first**: Define input schemas for every tool; document parameters and return shape.
+- **Errors**: Return structured errors or messages the model can interpret; avoid raw stack traces.
+- **Idempotency**: Prefer idempotent tools where possible so retries are safe.
+- **Rate and cost**: For tools that call external APIs, consider rate limits and cost; document in the tool description.
+- **Versioning**: Pin SDK version in package.json; check release notes when upgrading.
+
+## Official SDKs and Docs
+
+- **JavaScript/TypeScript**: `@modelcontextprotocol/sdk` (npm). Use Context7 with library name "MCP" for current registration and transport patterns.
+- **Go**: Official Go SDK on GitHub (`modelcontextprotocol/go-sdk`).
+- **C#**: Official C# SDK for .NET.