@vodailoc/kilo-kit-mcp 1.1.0

package/skills/operations/mcp-management/scripts/dist/cli.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/**
+ * MCP Management CLI - Command-line interface for MCP operations
+ */
+import { MCPClientManager } from './mcp-client.js';
+import { analyzeToolsForTask } from './analyze-tools.js';
+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 'analyze':
+                await analyzeForTask(manager, args.slice(1).join(' '));
+                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('');
+    }
+}
+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 analyzeForTask(manager, task) {
+    if (!task) {
+        console.error('Please provide a task description');
+        process.exit(1);
+    }
+    console.log(`Analyzing tools for task: "${task}"\n`);
+    const tools = await manager.getAllTools();
+    const analysis = analyzeToolsForTask(tools, task);
+    console.log(`Confidence: ${(analysis.confidence * 100).toFixed(1)}%`);
+    console.log(`\nRelevant tools (${analysis.relevantTools.length}):\n`);
+    for (let i = 0; i < analysis.relevantTools.length; i++) {
+        const tool = analysis.relevantTools[i];
+        console.log(`${i + 1}. ${tool.serverName} / ${tool.name}`);
+        console.log(`   ${analysis.reasoning[i]}`);
+        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 from all MCP servers
+  list-prompts            List all prompts from all MCP servers
+  list-resources          List all resources from all MCP servers
+  analyze <task>          Analyze which tools are relevant for a task
+  call-tool <server> <tool> <json>  Call a specific tool
+
+Examples:
+  cli.ts list-tools
+  cli.ts analyze "search the web for documentation"
+  cli.ts call-tool memory add '{"key":"name","value":"Alice"}'
+  `);
+}
+main();

package/skills/operations/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();
+            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();
+            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();
+            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 });
+    }
+    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 });
+    }
+    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 });
+    }
+    async cleanup() {
+        for (const client of this.clients.values()) {
+            await client.close();
+        }
+        this.clients.clear();
+    }
+}

package/skills/operations/mcp-management/scripts/mcp-client.ts

@@ -0,0 +1,163 @@
+#!/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();
+
+  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);
+    return client;
+  }
+
+  async connectAll(): Promise<void> {
+    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(): Promise<ToolInfo[]> {
+    const allTools: ToolInfo[] = [];
+    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 as any).outputSchema
+        });
+      }
+    }
+    return allTools;
+  }
+
+  async getAllPrompts(): Promise<PromptInfo[]> {
+    const allPrompts: PromptInfo[] = [];
+    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(): Promise<ResourceInfo[]> {
+    const allResources: ResourceInfo[] = [];
+    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: 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 }, { 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> {
+    for (const client of this.clients.values()) {
+      await client.close();
+    }
+    this.clients.clear();
+  }
+}

package/skills/operations/mcp-management/scripts/package.json

@@ -0,0 +1,18 @@
+{
+  "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",
+    "typescript": "^5.0.0",
+    "ts-node": "^10.0.0"
+  }
+}

package/skills/operations/mcp-management/scripts/tsconfig.json

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

package/skills/operations/powershell-windows/SKILL.md

@@ -0,0 +1,167 @@
+---
+name: powershell-windows
+description: PowerShell Windows patterns. Critical pitfalls, operator syntax, error handling.
+allowed-tools: Read, Write, Edit, Glob, Grep, Bash
+---
+
+# PowerShell Windows Patterns
+
+> Critical patterns and pitfalls for Windows PowerShell.
+
+---
+
+## 1. Operator Syntax Rules
+
+### CRITICAL: Parentheses Required
+
+| ❌ Wrong | ✅ Correct |
+|----------|-----------|
+| `if (Test-Path "a" -or Test-Path "b")` | `if ((Test-Path "a") -or (Test-Path "b"))` |
+| `if (Get-Item $x -and $y -eq 5)` | `if ((Get-Item $x) -and ($y -eq 5))` |
+
+**Rule:** Each cmdlet call MUST be in parentheses when using logical operators.
+
+---
+
+## 2. Unicode/Emoji Restriction
+
+### CRITICAL: No Unicode in Scripts
+
+| Purpose | ❌ Don't Use | ✅ Use |
+|---------|-------------|--------|
+| Success | ✅ ✓ | [OK] [+] |
+| Error | ❌ ✗ 🔴 | [!] [X] |
+| Warning | ⚠️ 🟡 | [*] [WARN] |
+| Info | ℹ️ 🔵 | [i] [INFO] |
+| Progress | ⏳ | [...] |
+
+**Rule:** Use ASCII characters only in PowerShell scripts.
+
+---
+
+## 3. Null Check Patterns
+
+### Always Check Before Access
+
+| ❌ Wrong | ✅ Correct |
+|----------|-----------|
+| `$array.Count -gt 0` | `$array -and $array.Count -gt 0` |
+| `$text.Length` | `if ($text) { $text.Length }` |
+
+---
+
+## 4. String Interpolation
+
+### Complex Expressions
+
+| ❌ Wrong | ✅ Correct |
+|----------|-----------|
+| `"Value: $($obj.prop.sub)"` | Store in variable first |
+
+**Pattern:**
+```
+$value = $obj.prop.sub
+Write-Output "Value: $value"
+```
+
+---
+
+## 5. Error Handling
+
+### ErrorActionPreference
+
+| Value | Use |
+|-------|-----|
+| Stop | Development (fail fast) |
+| Continue | Production scripts |
+| SilentlyContinue | When errors expected |
+
+### Try/Catch Pattern
+
+- Don't return inside try block
+- Use finally for cleanup
+- Return after try/catch
+
+---
+
+## 6. File Paths
+
+### Windows Path Rules
+
+| Pattern | Use |
+|---------|-----|
+| Literal path | `C:\Users\User\file.txt` |
+| Variable path | `Join-Path $env:USERPROFILE "file.txt"` |
+| Relative | `Join-Path $ScriptDir "data"` |
+
+**Rule:** Use Join-Path for cross-platform safety.
+
+---
+
+## 7. Array Operations
+
+### Correct Patterns
+
+| Operation | Syntax |
+|-----------|--------|
+| Empty array | `$array = @()` |
+| Add item | `$array += $item` |
+| ArrayList add | `$list.Add($item) | Out-Null` |
+
+---
+
+## 8. JSON Operations
+
+### CRITICAL: Depth Parameter
+
+| ❌ Wrong | ✅ Correct |
+|----------|-----------|
+| `ConvertTo-Json` | `ConvertTo-Json -Depth 10` |
+
+**Rule:** Always specify `-Depth` for nested objects.
+
+### File Operations
+
+| Operation | Pattern |
+|-----------|---------|
+| Read | `Get-Content "file.json" -Raw | ConvertFrom-Json` |
+| Write | `$data | ConvertTo-Json -Depth 10 | Out-File "file.json" -Encoding UTF8` |
+
+---
+
+## 9. Common Errors
+
+| Error Message | Cause | Fix |
+|---------------|-------|-----|
+| "parameter 'or'" | Missing parentheses | Wrap cmdlets in () |
+| "Unexpected token" | Unicode character | Use ASCII only |
+| "Cannot find property" | Null object | Check null first |
+| "Cannot convert" | Type mismatch | Use .ToString() |
+
+---
+
+## 10. Script Template
+
+```powershell
+# Strict mode
+Set-StrictMode -Version Latest
+$ErrorActionPreference = "Continue"
+
+# Paths
+$ScriptDir = Split-Path -Parent $MyInvocation.MyCommand.Path
+
+# Main
+try {
+    # Logic here
+    Write-Output "[OK] Done"
+    exit 0
+}
+catch {
+    Write-Warning "Error: $_"
+    exit 1
+}
+```
+
+---
+
+> **Remember:** PowerShell has unique syntax rules. Parentheses, ASCII-only, and null checks are non-negotiable.