cokit-cli 1.2.7 → 1.4.0

package/templates/repo/.github/skills/mcp-management/references/configuration.md

@@ -1,114 +0,0 @@
-# MCP Configuration Guide
-
-## Configuration File Structure
-
-MCP servers are configured in `$HOME/.copilot/.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "server-name": {
-      "command": "executable",
-      "args": ["arg1", "arg2"],
-      "env": {
-        "API_KEY": "value"
-      }
-    }
-  }
-}
-```
-
-## Common Server Configurations
-
-### Memory Server
-
-Store and retrieve key-value data:
-
-```json
-{
-  "memory": {
-    "command": "npx",
-    "args": ["-y", "@modelcontextprotocol/server-memory"]
-  }
-}
-```
-
-### Filesystem Server
-
-File operations with restricted access:
-
-```json
-{
-  "filesystem": {
-    "command": "npx",
-    "args": [
-      "-y",
-      "@modelcontextprotocol/server-filesystem",
-      "/allowed/path"
-    ]
-  }
-}
-```
-
-### Brave Search Server
-
-Web search capabilities:
-
-```json
-{
-  "brave-search": {
-    "command": "npx",
-    "args": ["-y", "@modelcontextprotocol/server-brave-search"],
-    "env": {
-      "BRAVE_API_KEY": "${BRAVE_API_KEY}"
-    }
-  }
-}
-```
-
-### Puppeteer Server
-
-Browser automation:
-
-```json
-{
-  "puppeteer": {
-    "command": "npx",
-    "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
-  }
-}
-```
-
-## Environment Variables
-
-Reference env vars with `${VAR_NAME}` syntax:
-
-```json
-{
-  "api-server": {
-    "command": "node",
-    "args": ["server.js"],
-    "env": {
-      "API_KEY": "${MY_API_KEY}",
-      "BASE_URL": "${API_BASE_URL}"
-    }
-  }
-}
-```
-
-## Configuration Loading Order
-
-Scripts check for config in this order:
-
-1. `process.env` (runtime environment)
-2. `$HOME/.copilot/skills/mcp-management/.env`
-3. `$HOME/.copilot/skills/.env`
-4. `$HOME/.copilot/.env`
-
-## Validation
-
-Config must:
-- Be valid JSON
-- Include `mcpServers` object
-- Each server must have `command` and `args`
-- `env` is optional but must be object if present

package/templates/repo/.github/skills/mcp-management/references/gemini-cli-integration.md

@@ -1,221 +0,0 @@
-# Gemini CLI Integration Guide
-
-## Model Configuration
-
-Read model from `$HOME/.copilot/.ck.json`: `gemini.model` (default: `gemini-3.0-flash`)
-
-## ⚠️ CRITICAL: Use Stdin Piping, NOT -p Flag
-
-The `-p` flag is **deprecated** and skips MCP server initialization, causing tools to be unavailable:
-
-```bash
-# ❌ WRONG - Deprecated -p flag skips MCP connections!
-gemini -y -m <gemini.model> -p "Take a screenshot"
-# Also wrong: Using --model instead of -m
-gemini -y -p "Take a screenshot" --model gemini-3.0-flash
-
-# ✅ CORRECT - This initializes MCP servers
-echo "Take a screenshot" | gemini -y -m <gemini.model>
-```
-
-**Why**: The `-p` flag runs in "quick mode" and bypasses MCP server connection initialization. Always use stdin piping (echo + pipe) to ensure MCP tools are available.
-
-## Overview
-
-Gemini CLI provides automatic MCP tool discovery and execution via natural language prompts. This is the recommended primary method for executing MCP tools.
-
-## Installation
-
-```bash
-npm install -g gemini-cli
-```
-
-Verify installation:
-```bash
-gemini --version
-```
-
-## Configuration
-
-### Symlink Setup
-
-Gemini CLI reads MCP servers from `.gemini/settings.json`. Create a symlink to `$HOME/.copilot/.mcp.json`:
-
-```bash
-# Create .gemini directory
-mkdir -p .gemini
-
-# Create symlink (Unix/Linux/macOS)
-ln -sf $HOME/.copilot/.mcp.json .gemini/settings.json
-
-# Create symlink (Windows - requires admin or developer mode)
-mklink .gemini\settings.json .copilot\.mcp.json
-```
-
-### Security
-
-Add to `.gitignore`:
-```
-.gemini/settings.json
-```
-
-This prevents committing sensitive API keys and server configurations.
-
-## Usage
-
-### Basic Syntax
-
-```bash
-# IMPORTANT: Use stdin piping, NOT -p flag (deprecated, skips MCP init)
-echo "<prompt>" | gemini [flags]
-```
-
-### Essential Flags
-
-- `-y`: Skip confirmation prompts (auto-approve tool execution)
-- `-m <model>`: Model selection
-  - `gemini-3.0-flash` (fast, recommended for MCP)
-  - `gemini-3.0-flash` (balanced)
-  - `gemini-pro` (high quality)
-
-### Examples
-
-**Screenshot Capture**:
-```bash
-echo "Take a screenshot of https://www.google.com.vn" | gemini -y -m <gemini.model>
-```
-
-**Memory Operations**:
-```bash
-echo "Remember that Alice is a React developer working on e-commerce projects" | gemini -y -m <gemini.model>
-```
-
-**Web Research**:
-```bash
-echo "Search for latest Next.js 15 features and summarize the top 3" | gemini -y -m <gemini.model>
-```
-
-**Multi-Tool Orchestration**:
-```bash
-echo "Search for AI documentation, take a screenshot of the homepage, and save both to memory" | gemini -y -m <gemini.model>
-```
-
-**Browser Automation**:
-```bash
-echo "Navigate to https://example.com, click the signup button, and take a screenshot" | gemini -y -m <gemini.model>
-```
-
-## How It Works
-
-1. **Configuration Loading**: Reads `.gemini/settings.json` (symlinked to `$HOME/.copilot/.mcp.json`)
-2. **Server Connection**: Connects to all configured MCP servers
-3. **Tool Discovery**: Lists all available tools from servers
-4. **Prompt Analysis**: Gemini model analyzes the prompt
-5. **Tool Selection**: Automatically selects relevant tools
-6. **Execution**: Calls tools with appropriate parameters
-7. **Result Synthesis**: Combines tool outputs into coherent response
-
-## Advanced Configuration
-
-### Trusted Servers (Skip Confirmations)
-
-Edit `$HOME/.copilot/.mcp.json`:
-
-```json
-{
-  "mcpServers": {
-    "memory": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-memory"],
-      "trust": true
-    }
-  }
-}
-```
-
-With `trust: true`, the `-y` flag is unnecessary.
-
-### Tool Filtering
-
-Limit tool exposure:
-
-```json
-{
-  "mcpServers": {
-    "chrome-devtools": {
-      "command": "npx",
-      "args": ["-y", "chrome-devtools-mcp@latest"],
-      "includeTools": ["navigate_page", "screenshot"],
-      "excludeTools": ["evaluate_js"]
-    }
-  }
-}
-```
-
-### Environment Variables
-
-Use `$VAR_NAME` syntax for sensitive data:
-
-```json
-{
-  "mcpServers": {
-    "brave-search": {
-      "command": "npx",
-      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
-      "env": {
-        "BRAVE_API_KEY": "$BRAVE_API_KEY"
-      }
-    }
-  }
-}
-```
-
-## Troubleshooting
-
-### Check MCP Status
-
-```bash
-gemini
-> /mcp
-```
-
-Shows:
-- Connected servers
-- Available tools
-- Configuration errors
-
-### Verify Symlink
-
-```bash
-# Unix/Linux/macOS
-ls -la .gemini/settings.json
-
-# Windows
-dir .gemini\settings.json
-```
-
-Should show symlink pointing to `$HOME/.copilot/.mcp.json`.
-
-### Debug Mode
-
-```bash
-echo "Take a screenshot" | gemini --debug
-```
-
-Shows detailed MCP communication logs.
-
-## Comparison with Alternatives
-
-| Method | Speed | Flexibility | Setup | Best For |
-|--------|-------|-------------|-------|----------|
-| Gemini CLI | ⭐⭐⭐ | ⭐⭐⭐ | ⭐⭐ | All tasks |
-| Direct Scripts | ⭐⭐ | ⭐⭐⭐ | ⭐⭐⭐ | Specific tools |
-| mcp-manager | ⭐ | ⭐⭐ | ⭐⭐⭐ | Fallback |
-
-**Recommendation**: Use Gemini CLI as primary method, fallback to scripts/agent when unavailable.
-
-## Resources
-
-- [Gemini CLI Documentation](https://geminicli.com/docs)
-- [MCP Server Configuration](https://geminicli.com/docs/tools/mcp-server)
-- [Tool Reference](https://geminicli.com/docs/tools/mcp-server/#tool-interaction)

package/templates/repo/.github/skills/mcp-management/scripts/.env.example

@@ -1,10 +0,0 @@
-# MCP Management Scripts Environment Variables
-
-# Path to MCP configuration file (optional, defaults to .copilot/.mcp.json)
-MCP_CONFIG_PATH=.copilot/.mcp.json
-
-# Logging level (optional, defaults to info)
-LOG_LEVEL=info
-
-# Enable debug mode (optional, defaults to false)
-DEBUG=false

package/templates/repo/.github/skills/mcp-management/scripts/dist/analyze-tools.js

@@ -1,70 +0,0 @@
-#!/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/templates/repo/.github/skills/mcp-management/scripts/dist/cli.js

@@ -1,160 +0,0 @@
-#!/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);
-const GLOBAL_TIMEOUT_MS = parseInt(process.env.MCP_TIMEOUT || '120000', 10);
-let globalManager = null;
-function setupShutdownHandlers() {
-    const shutdown = async (signal) => {
-        console.log(`\nReceived ${signal}, cleaning up...`);
-        if (globalManager) {
-            await globalManager.cleanup();
-        }
-        process.exit(0);
-    };
-    process.on('SIGINT', () => shutdown('SIGINT'));
-    process.on('SIGTERM', () => shutdown('SIGTERM'));
-    process.on('SIGHUP', () => shutdown('SIGHUP'));
-    process.on('unhandledRejection', (reason) => {
-        console.error('Unhandled rejection:', reason);
-        process.exit(1);
-    });
-}
-async function main() {
-    const args = process.argv.slice(2);
-    const command = args[0];
-    // Setup shutdown handlers
-    setupShutdownHandlers();
-    // Check for help flags BEFORE connecting to servers
-    if (!command || command === '--help' || command === 'help') {
-        printUsage();
-        process.exit(0);
-    }
-    // Global timeout
-    const timeoutHandle = setTimeout(() => {
-        console.error('Global timeout exceeded, forcing exit');
-        process.exit(1);
-    }, GLOBAL_TIMEOUT_MS);
-    timeoutHandle.unref();
-    const manager = new MCPClientManager();
-    globalManager = manager;
-    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();
-        process.exit(0);
-    }
-    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();