anchi-toolkit 1.2.0 → 1.2.2

package/dist/.cursor/skills/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 = '.cursor/.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/dist/.cursor/skills/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/dist/.cursor/skills/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/dist/.cursor/skills/media-processing/SKILL.md

@@ -0,0 +1,91 @@
+---
+name: media-processing
+description: Process multimedia files with FFmpeg (video/audio encoding, conversion, streaming, filtering, hardware acceleration), ImageMagick (image manipulation, format conversion, batch processing, effects, composition), and RMBG (AI-powered background removal). Use when converting media formats, encoding videos with specific codecs (H.264, H.265, VP9), resizing/cropping images, removing backgrounds from images, extracting audio from video, applying filters and effects, optimizing file sizes, creating streaming manifests (HLS/DASH), generating thumbnails, batch processing images, creating composite images, or implementing media processing pipelines. Supports 100+ formats, hardware acceleration (NVENC, QSV), and complex filtergraphs.
+license: MIT
+---
+
+# Media Processing Skill
+
+Process video, audio, and images using FFmpeg, ImageMagick, and RMBG CLI tools.
+
+## Tool Selection
+
+| Task | Tool | Reason |
+|------|------|--------|
+| Video encoding/conversion | FFmpeg | Native codec support, streaming |
+| Audio extraction/conversion | FFmpeg | Direct stream manipulation |
+| Image resize/effects | ImageMagick | Optimized for still images |
+| Background removal | RMBG | AI-powered, local processing |
+| Batch images | ImageMagick | mogrify for in-place edits |
+| Video thumbnails | FFmpeg | Frame extraction built-in |
+| GIF creation | FFmpeg/ImageMagick | FFmpeg for video, ImageMagick for images |
+
+## Installation
+
+```bash
+# macOS
+brew install ffmpeg imagemagick
+npm install -g rmbg-cli
+
+# Ubuntu/Debian
+sudo apt-get install ffmpeg imagemagick
+npm install -g rmbg-cli
+
+# Verify
+ffmpeg -version && magick -version && rmbg --version
+```
+
+## Essential Commands
+
+```bash
+# Video: Convert/re-encode
+ffmpeg -i input.mkv -c copy output.mp4
+ffmpeg -i input.avi -c:v libx264 -crf 22 -c:a aac output.mp4
+
+# Video: Extract audio
+ffmpeg -i video.mp4 -vn -c:a copy audio.m4a
+
+# Image: Convert/resize
+magick input.png output.jpg
+magick input.jpg -resize 800x600 output.jpg
+
+# Image: Batch resize
+mogrify -resize 800x -quality 85 *.jpg
+
+# Background removal
+rmbg input.jpg                          # Basic (modnet)
+rmbg input.jpg -m briaai -o output.png  # High quality
+rmbg input.jpg -m u2netp -o output.png  # Fast
+```
+
+## Key Parameters
+
+**FFmpeg:**
+- `-c:v libx264` - H.264 codec
+- `-crf 22` - Quality (0-51, lower=better)
+- `-preset slow` - Speed/compression balance
+- `-c:a aac` - Audio codec
+
+**ImageMagick:**
+- `800x600` - Fit within (maintains aspect)
+- `800x600^` - Fill (may crop)
+- `-quality 85` - JPEG quality
+- `-strip` - Remove metadata
+
+**RMBG:**
+- `-m briaai` - High quality model
+- `-m u2netp` - Fast model
+- `-r 4096` - Max resolution
+
+## References
+
+Detailed guides in `references/`:
+- `ffmpeg-encoding.md` - Codecs, quality, hardware acceleration
+- `ffmpeg-streaming.md` - HLS/DASH, live streaming
+- `ffmpeg-filters.md` - Filters, complex filtergraphs
+- `imagemagick-editing.md` - Effects, transformations
+- `imagemagick-batch.md` - Batch processing, parallel ops
+- `rmbg-background-removal.md` - AI models, CLI usage
+- `common-workflows.md` - Video optimization, responsive images, GIF creation
+- `troubleshooting.md` - Error fixes, performance tips
+- `format-compatibility.md` - Format support, codec recommendations

package/dist/.cursor/skills/media-processing/references/common-workflows.md

@@ -0,0 +1,132 @@
+# Common Media Processing Workflows
+
+## Video Optimization
+
+### Optimize for Web
+```bash
+# H.264 with good compression
+ffmpeg -i input.mp4 \
+  -c:v libx264 -preset slow -crf 23 \
+  -c:a aac -b:a 128k \
+  -movflags +faststart \
+  output.mp4
+```
+
+### Multi-Pass Encoding
+```bash
+# Pass 1 (analysis)
+ffmpeg -y -i input.mkv -c:v libx264 -b:v 2600k -pass 1 -an -f null /dev/null
+
+# Pass 2 (encoding)
+ffmpeg -i input.mkv -c:v libx264 -b:v 2600k -pass 2 -c:a aac output.mp4
+```
+
+### Hardware-Accelerated Encoding
+```bash
+# NVIDIA NVENC
+ffmpeg -hwaccel cuda -i input.mp4 -c:v h264_nvenc -preset fast -crf 22 output.mp4
+
+# Intel QuickSync
+ffmpeg -hwaccel qsv -c:v h264_qsv -i input.mp4 -c:v h264_qsv output.mp4
+```
+
+### Extract Video Segment
+```bash
+# From 1:30 to 3:00 (re-encode for precision)
+ffmpeg -i input.mp4 -ss 00:01:30 -to 00:03:00 \
+  -c:v libx264 -c:a aac output.mp4
+```
+
+## Image Workflows
+
+### Create Responsive Images
+```bash
+# Generate multiple sizes
+for size in 320 640 1024 1920; do
+  magick input.jpg -resize ${size}x -quality 85 "output-${size}w.jpg"
+done
+```
+
+### Batch Image Optimization
+```bash
+# Convert PNG to optimized JPEG
+mogrify -path ./optimized -format jpg -quality 85 -strip *.png
+```
+
+### Complex Image Pipeline
+```bash
+# Resize, crop, border, adjust
+magick input.jpg \
+  -resize 1000x1000^ \
+  -gravity center \
+  -crop 1000x1000+0+0 +repage \
+  -bordercolor black -border 5x5 \
+  -brightness-contrast 5x10 \
+  -quality 90 \
+  output.jpg
+```
+
+## GIF Creation
+
+### Video to GIF
+```bash
+# High quality GIF with palette
+ffmpeg -i input.mp4 -vf "fps=15,scale=640:-1:flags=lanczos,split[s0][s1];[s0]palettegen[p];[s1][p]paletteuse" output.gif
+```
+
+### Animated GIF from Images
+```bash
+# Create with delay
+magick -delay 100 -loop 0 frame*.png animated.gif
+
+# Optimize size
+magick animated.gif -fuzz 5% -layers Optimize optimized.gif
+```
+
+## Background Removal Workflows
+
+### Batch Background Removal
+```bash
+# Process all images in directory
+for img in *.jpg; do
+  rmbg "$img" -m modnet -o "${img%.jpg}-no-bg.png"
+done
+```
+
+### Product Photography
+```bash
+# 1. Remove background
+rmbg product.jpg -m u2net-cloth -o product-no-bg.png
+
+# 2. Resize to multiple sizes
+magick product-no-bg.png -resize 800x800 product-800.png
+magick product-no-bg.png -resize 400x400 product-400.png
+
+# 3. Add white background if needed
+magick product-no-bg.png -background white -flatten product-white-bg.jpg
+```
+
+## Media Analysis
+
+### Inspect Video Properties
+```bash
+# Detailed JSON output
+ffprobe -v quiet -print_format json -show_format -show_streams input.mp4
+
+# Get resolution
+ffprobe -v error -select_streams v:0 \
+  -show_entries stream=width,height \
+  -of csv=s=x:p=0 input.mp4
+```
+
+### Image Information
+```bash
+# Basic info
+identify image.jpg
+
+# Detailed format
+identify -verbose image.jpg
+
+# Custom format
+identify -format "%f: %wx%h %b\n" image.jpg
+```