@vodailoc/kilo-kit-mcp 1.1.0 → 1.2.0

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

@@ -1,163 +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();
-  }
-}
+#!/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

@@ -1,18 +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"
-  }
-}
+{
+  "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

@@ -1,15 +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"]
-}
+{
+  "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/problem-solving/collision-zone-thinking/SKILL.md

@@ -1,62 +1,62 @@
----
-name: Collision-Zone Thinking
-description: Force unrelated concepts together to discover emergent properties - "What if we treated X like Y?"
-when_to_use: when conventional approaches feel inadequate and you need breakthrough innovation by forcing unrelated concepts together
-version: 1.1.0
----
-
-# Collision-Zone Thinking
-
-## Overview
-
-Revolutionary insights come from forcing unrelated concepts to collide. Treat X like Y and see what emerges.
-
-**Core principle:** Deliberate metaphor-mixing generates novel solutions.
-
-## Quick Reference
-
-| Stuck On | Try Treating As | Might Discover |
-|----------|-----------------|----------------|
-| Code organization | DNA/genetics | Mutation testing, evolutionary algorithms |
-| Service architecture | Lego bricks | Composable microservices, plug-and-play |
-| Data management | Water flow | Streaming, data lakes, flow-based systems |
-| Request handling | Postal mail | Message queues, async processing |
-| Error handling | Circuit breakers | Fault isolation, graceful degradation |
-
-## Process
-
-1. **Pick two unrelated concepts** from different domains
-2. **Force combination**: "What if we treated [A] like [B]?"
-3. **Explore emergent properties**: What new capabilities appear?
-4. **Test boundaries**: Where does the metaphor break?
-5. **Extract insight**: What did we learn?
-
-## Example Collision
-
-**Problem:** Complex distributed system with cascading failures
-
-**Collision:** "What if we treated services like electrical circuits?"
-
-**Emergent properties:**
-- Circuit breakers (disconnect on overload)
-- Fuses (one-time failure protection)
-- Ground faults (error isolation)
-- Load balancing (current distribution)
-
-**Where it works:** Preventing cascade failures
-**Where it breaks:** Circuits don't have retry logic
-**Insight gained:** Failure isolation patterns from electrical engineering
-
-## Red Flags You Need This
-
-- "I've tried everything in this domain"
-- Solutions feel incremental, not breakthrough
-- Stuck in conventional thinking
-- Need innovation, not optimization
-
-## Remember
-
-- Wild combinations often yield best insights
-- Test metaphor boundaries rigorously
-- Document even failed collisions (they teach)
-- Best source domains: physics, biology, economics, psychology
+---
+name: Collision-Zone Thinking
+description: Force unrelated concepts together to discover emergent properties - "What if we treated X like Y?"
+when_to_use: when conventional approaches feel inadequate and you need breakthrough innovation by forcing unrelated concepts together
+version: 1.1.0
+---
+
+# Collision-Zone Thinking
+
+## Overview
+
+Revolutionary insights come from forcing unrelated concepts to collide. Treat X like Y and see what emerges.
+
+**Core principle:** Deliberate metaphor-mixing generates novel solutions.
+
+## Quick Reference
+
+| Stuck On | Try Treating As | Might Discover |
+|----------|-----------------|----------------|
+| Code organization | DNA/genetics | Mutation testing, evolutionary algorithms |
+| Service architecture | Lego bricks | Composable microservices, plug-and-play |
+| Data management | Water flow | Streaming, data lakes, flow-based systems |
+| Request handling | Postal mail | Message queues, async processing |
+| Error handling | Circuit breakers | Fault isolation, graceful degradation |
+
+## Process
+
+1. **Pick two unrelated concepts** from different domains
+2. **Force combination**: "What if we treated [A] like [B]?"
+3. **Explore emergent properties**: What new capabilities appear?
+4. **Test boundaries**: Where does the metaphor break?
+5. **Extract insight**: What did we learn?
+
+## Example Collision
+
+**Problem:** Complex distributed system with cascading failures
+
+**Collision:** "What if we treated services like electrical circuits?"
+
+**Emergent properties:**
+- Circuit breakers (disconnect on overload)
+- Fuses (one-time failure protection)
+- Ground faults (error isolation)
+- Load balancing (current distribution)
+
+**Where it works:** Preventing cascade failures
+**Where it breaks:** Circuits don't have retry logic
+**Insight gained:** Failure isolation patterns from electrical engineering
+
+## Red Flags You Need This
+
+- "I've tried everything in this domain"
+- Solutions feel incremental, not breakthrough
+- Stuck in conventional thinking
+- Need innovation, not optimization
+
+## Remember
+
+- Wild combinations often yield best insights
+- Test metaphor boundaries rigorously
+- Document even failed collisions (they teach)
+- Best source domains: physics, biology, economics, psychology