@aiwg/cli 0.0.0-bootstrap.0 → 2026.7.17

package/dist/src/smiths/mcpsmith/analyzers/cli-analyzer.js

@@ -0,0 +1,390 @@
+/**
+ * CLI Analyzer for MCPsmith
+ *
+ * Parses CLI tool help output to extract tool definitions.
+ *
+ * @architecture @.aiwg/architecture/mcpsmith-architecture.md - Section 5.1
+ * @implements @.aiwg/architecture/decisions/ADR-014-mcpsmith-mcp-server-generator.md
+ */
+import { spawn } from 'child_process';
+/**
+ * Analyze a CLI tool and extract MCP tool definitions
+ */
+export async function analyzeCLI(options) {
+    const { command, includeSubcommands = true, 
+    // maxDepth and parseManPage reserved for future use
+    timeout = 5000 } = options;
+    // Get command version
+    const version = await getCommandVersion(command, timeout);
+    // Get help output
+    const helpText = await getHelpOutput(command, timeout);
+    // Parse help text
+    const parsed = parseHelpText(helpText, command);
+    // Extract tool definitions
+    const tools = [];
+    // If there are subcommands, generate tools for each
+    if (includeSubcommands && parsed.subcommands.length > 0) {
+        for (const subcommand of parsed.subcommands) {
+            const tool = subcommandToTool(command, subcommand, parsed.globalFlags);
+            tools.push(tool);
+        }
+    }
+    else {
+        // Generate single tool for the command
+        const tool = commandToTool(command, parsed);
+        tools.push(tool);
+    }
+    return {
+        tools,
+        metadata: {
+            sourceType: 'cli',
+            sourceName: command,
+            sourceVersion: version,
+            discoveredAt: new Date().toISOString(),
+            toolCount: tools.length
+        }
+    };
+}
+/**
+ * Get command version
+ */
+async function getCommandVersion(command, timeout) {
+    try {
+        // Try common version flags
+        const versionFlags = ['--version', '-v', 'version', '-V'];
+        for (const flag of versionFlags) {
+            try {
+                const output = await executeCommand(command, [flag], timeout);
+                if (output && output.trim().length > 0) {
+                    // Extract version number from output
+                    const versionMatch = output.match(/\d+\.\d+(\.\d+)?/);
+                    if (versionMatch) {
+                        return versionMatch[0];
+                    }
+                    // Return first line if no version number found
+                    return output.split('\n')[0].trim();
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Get help output for command
+ */
+async function getHelpOutput(command, timeout) {
+    const helpFlags = ['--help', '-h', 'help'];
+    for (const flag of helpFlags) {
+        try {
+            const output = await executeCommand(command, [flag], timeout);
+            if (output && output.trim().length > 0) {
+                return output;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error(`Could not get help output for command: ${command}`);
+}
+/**
+ * Execute command and capture output
+ */
+function executeCommand(command, args, timeout) {
+    return new Promise((resolve, reject) => {
+        const proc = spawn(command, args, {
+            timeout,
+            stdio: ['ignore', 'pipe', 'pipe']
+        });
+        let stdout = '';
+        let stderr = '';
+        proc.stdout.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.stderr.on('data', (data) => {
+            stderr += data.toString();
+        });
+        proc.on('close', (code) => {
+            // Many commands output help to stderr
+            const output = stdout || stderr;
+            if (output.trim().length > 0) {
+                resolve(output);
+            }
+            else {
+                reject(new Error(`Command exited with code ${code}`));
+            }
+        });
+        proc.on('error', reject);
+    });
+}
+/**
+ * Parse help text into structured format
+ */
+function parseHelpText(helpText, command) {
+    const lines = helpText.split('\n');
+    // Extract description (usually first non-empty line or after "NAME:")
+    const description = extractDescription(lines);
+    // Extract subcommands
+    const subcommands = extractSubcommands(lines);
+    // Extract global flags/options
+    const globalFlags = extractFlags(lines);
+    return {
+        command,
+        description,
+        subcommands,
+        globalFlags
+    };
+}
+/**
+ * Extract description from help text
+ */
+function extractDescription(lines) {
+    // Look for description after NAME: or DESCRIPTION:
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/^(NAME|DESCRIPTION):/i.test(line)) {
+            // Next line is usually the description
+            if (i + 1 < lines.length) {
+                return lines[i + 1].trim();
+            }
+        }
+    }
+    // Otherwise use first non-empty line
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('-') && !trimmed.startsWith('Usage:')) {
+            return trimmed;
+        }
+    }
+    return 'CLI tool';
+}
+/**
+ * Extract subcommands from help text
+ */
+function extractSubcommands(lines) {
+    const subcommands = [];
+    let inSubcommandsSection = false;
+    // Patterns for subcommand sections
+    const sectionPatterns = /^(COMMANDS|SUBCOMMANDS|Available commands):/i;
+    // Pattern for subcommand line: "  command    description"
+    const subcommandPattern = /^  ([a-z][a-z0-9-_]*)\s{2,}(.+)$/i;
+    for (const line of lines) {
+        // Check if we're entering subcommands section
+        if (sectionPatterns.test(line)) {
+            inSubcommandsSection = true;
+            continue;
+        }
+        // Check if we're leaving section (next section header or empty line)
+        if (inSubcommandsSection && (/^[A-Z\s]+:/.test(line) || line.trim() === '')) {
+            if (/^[A-Z\s]+:/.test(line)) {
+                inSubcommandsSection = false;
+            }
+            continue;
+        }
+        // Parse subcommand line
+        if (inSubcommandsSection) {
+            const match = line.match(subcommandPattern);
+            if (match) {
+                subcommands.push({
+                    name: match[1],
+                    description: match[2].trim(),
+                    flags: [],
+                    arguments: []
+                });
+            }
+        }
+    }
+    return subcommands;
+}
+/**
+ * Extract flags/options from help text
+ */
+function extractFlags(lines) {
+    const flags = [];
+    let inOptionsSection = false;
+    // Patterns for options section
+    const sectionPatterns = /^(OPTIONS|FLAGS):/i;
+    // Pattern for flag line: "  -s, --long <arg>    description"
+    const flagPattern = /^\s+(-[a-z])?,?\s*(--[a-z][a-z0-9-_]*)?(?:\s+<([^>]+)>|\s+\[([^\]]+)\])?\s{2,}(.+)$/i;
+    for (const line of lines) {
+        // Check if we're entering options section
+        if (sectionPatterns.test(line)) {
+            inOptionsSection = true;
+            continue;
+        }
+        // Check if we're leaving section
+        if (inOptionsSection && /^[A-Z\s]+:/.test(line)) {
+            inOptionsSection = false;
+            continue;
+        }
+        // Parse flag line
+        if (inOptionsSection) {
+            const match = line.match(flagPattern);
+            if (match) {
+                const [, short, long, requiredArg, optionalArg, description] = match;
+                const hasArg = !!(requiredArg || optionalArg);
+                flags.push({
+                    short,
+                    long,
+                    description: description.trim(),
+                    type: hasArg ? 'string' : 'boolean',
+                    required: !!requiredArg
+                });
+            }
+        }
+    }
+    return flags;
+}
+/**
+ * Convert subcommand to MCP tool definition
+ */
+function subcommandToTool(command, subcommand, globalFlags) {
+    const toolName = `${command}-${subcommand.name}`;
+    const mapping = {};
+    const properties = {};
+    const required = [];
+    // Add flags to schema
+    const allFlags = [...globalFlags, ...subcommand.flags];
+    for (const flag of allFlags) {
+        const paramName = (flag.long || flag.short || '').replace(/^-+/, '');
+        if (!paramName)
+            continue;
+        mapping[paramName] = {
+            flag: flag.long || flag.short,
+            type: flag.type
+        };
+        properties[paramName] = {
+            type: flag.type,
+            description: flag.description
+        };
+        if (flag.required) {
+            required.push(paramName);
+        }
+        if (flag.default) {
+            properties[paramName].default = flag.default;
+        }
+    }
+    // Add arguments to schema
+    for (const arg of subcommand.arguments) {
+        mapping[arg.name] = {
+            position: arg.position,
+            type: arg.type
+        };
+        properties[arg.name] = {
+            type: arg.type,
+            description: arg.description
+        };
+        if (arg.required) {
+            required.push(arg.name);
+        }
+    }
+    return {
+        name: toolName,
+        title: `${command} ${subcommand.name}`,
+        description: subcommand.description,
+        source: {
+            type: 'cli',
+            command,
+            subcommand: subcommand.name,
+            mapping
+        },
+        inputSchema: {
+            type: 'object',
+            properties,
+            required: required.length > 0 ? required : undefined
+        },
+        examples: [],
+        metadata: {
+            dangerous: isDangerousCommand(command, subcommand.name),
+            requiresConfirmation: requiresConfirmation(command, subcommand.name),
+            retryable: true
+        }
+    };
+}
+/**
+ * Convert command to MCP tool definition (for commands without subcommands)
+ */
+function commandToTool(command, parsed) {
+    const mapping = {};
+    const properties = {};
+    const required = [];
+    // Add flags to schema
+    for (const flag of parsed.globalFlags) {
+        const paramName = (flag.long || flag.short || '').replace(/^-+/, '');
+        if (!paramName)
+            continue;
+        mapping[paramName] = {
+            flag: flag.long || flag.short,
+            type: flag.type
+        };
+        properties[paramName] = {
+            type: flag.type,
+            description: flag.description
+        };
+        if (flag.required) {
+            required.push(paramName);
+        }
+        if (flag.default) {
+            properties[paramName].default = flag.default;
+        }
+    }
+    return {
+        name: command,
+        title: command,
+        description: parsed.description,
+        source: {
+            type: 'cli',
+            command,
+            mapping
+        },
+        inputSchema: {
+            type: 'object',
+            properties,
+            required: required.length > 0 ? required : undefined
+        },
+        examples: [],
+        metadata: {
+            dangerous: isDangerousCommand(command),
+            requiresConfirmation: requiresConfirmation(command),
+            retryable: true
+        }
+    };
+}
+/**
+ * Check if command/subcommand is dangerous
+ */
+function isDangerousCommand(command, subcommand) {
+    const dangerousPatterns = [
+        /rm/i,
+        /delete/i,
+        /remove/i,
+        /format/i,
+        /erase/i,
+        /destroy/i,
+        /force/i,
+        /hard/i
+    ];
+    const fullCommand = subcommand ? `${command}-${subcommand}` : command;
+    return dangerousPatterns.some(pattern => pattern.test(fullCommand));
+}
+/**
+ * Check if command requires confirmation
+ */
+function requiresConfirmation(command, subcommand) {
+    const confirmationPatterns = [
+        /push/i,
+        /deploy/i,
+        /publish/i,
+        /reset/i,
+        /rebase/i
+    ];
+    const fullCommand = subcommand ? `${command}-${subcommand}` : command;
+    return confirmationPatterns.some(pattern => pattern.test(fullCommand));
+}
+//# sourceMappingURL=cli-analyzer.js.map

package/dist/src/smiths/mcpsmith/example.js

@@ -0,0 +1,119 @@
+/**
+ * MCPsmith Example Usage
+ *
+ * Demonstrates how to use MCPsmith to generate MCP servers.
+ *
+ * @example
+ * ```bash
+ * node --loader ts-node/esm src/smiths/mcpsmith/example.ts
+ * ```
+ */
+import { analyzeCLI } from './analyzers/cli-analyzer.js';
+import { generateServer, updateRegistry } from './generator.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+async function main() {
+    console.log('MCPsmith Example: Generating Git MCP Server\n');
+    // Step 1: Analyze the git CLI tool
+    console.log('Step 1: Analyzing git command...');
+    const analyzerResult = await analyzeCLI({
+        command: 'git',
+        includeSubcommands: true,
+        maxDepth: 1,
+        timeout: 5000
+    });
+    console.log(`  Found ${analyzerResult.tools.length} tools`);
+    console.log(`  Version: ${analyzerResult.metadata.sourceVersion || 'unknown'}`);
+    console.log();
+    // Step 2: Generate the MCP server
+    console.log('Step 2: Generating MCP server...');
+    const outputDir = path.join(__dirname, '..', '..', '..', '.aiwg', 'smiths', 'mcpsmith', 'servers');
+    const generatedServer = await generateServer({
+        serverId: 'git',
+        serverName: 'Git CLI MCP Server',
+        description: 'Exposes git commands as MCP tools',
+        analyzerResult,
+        config: {
+            tools: {
+                // Only allow safe git commands
+                prefix: 'git',
+                allowlist: ['status', 'log', 'diff', 'branch', 'show'],
+                denylist: ['push', 'force', 'reset'],
+                dangerousCommands: {
+                    require_confirmation: ['checkout', 'merge'],
+                    blocked: ['push --force', 'reset --hard', 'clean -fd']
+                }
+            },
+            security: {
+                sandboxed: true,
+                maxExecutionTime: 30000,
+                allowedPaths: [process.cwd()],
+                blockedCommands: [],
+                requireConfirmation: []
+            }
+        },
+        outputDir
+    });
+    console.log(`  Server generated at: ${generatedServer.path}`);
+    console.log(`  Files created:`);
+    console.log(`    - ${path.basename(generatedServer.files.server)}`);
+    console.log(`    - ${path.basename(generatedServer.files.config)}`);
+    console.log(`    - ${path.basename(generatedServer.files.manifest)}`);
+    console.log(`    - ${generatedServer.files.tools.length} tool definitions`);
+    console.log();
+    // Step 3: Update registry
+    console.log('Step 3: Updating registry...');
+    const registryPath = path.join(path.dirname(outputDir), 'registry.json');
+    const serverEntry = {
+        id: 'git',
+        name: 'Git CLI MCP Server',
+        description: 'Exposes git commands as MCP tools',
+        version: '1.0.0',
+        source: {
+            type: 'cli',
+            command: 'git',
+            discovery: 'help-parsing'
+        },
+        status: 'active',
+        path: `servers/${generatedServer.id}/`,
+        transport: 'stdio',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        tools: analyzerResult.tools.map(t => t.name),
+        resources: [],
+        prompts: [],
+        health: {
+            status: 'unknown',
+            lastCheck: new Date().toISOString()
+        }
+    };
+    await updateRegistry(registryPath, 'git', serverEntry);
+    console.log(`  Registry updated at: ${registryPath}`);
+    console.log();
+    // Step 4: Display usage instructions
+    console.log('Step 4: Usage Instructions');
+    console.log('  To test the generated server:');
+    console.log(`  node ${generatedServer.files.server}`);
+    console.log();
+    console.log('  To register with Claude Code:');
+    console.log('  Add to .claude/settings.local.json:');
+    console.log('  {');
+    console.log('    "mcpServers": {');
+    console.log('      "git": {');
+    console.log('        "command": "node",');
+    console.log(`        "args": ["${generatedServer.files.server}"]`);
+    console.log('      }');
+    console.log('    }');
+    console.log('  }');
+    console.log();
+    console.log('Example complete!');
+}
+// Run example if executed directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+    main().catch(error => {
+        console.error('Error:', error);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=example.js.map