@skillsmith/cli 0.2.2 → 0.2.4

package/dist/src/commands/author.d.ts

@@ -29,5 +29,48 @@ export declare function createValidateCommand(): Command;
  * Create publish command
  */
 export declare function createPublishCommand(): Command;
-export { initSkill, validateSkill, publishSkill };
+interface SubagentOptions {
+    output?: string | undefined;
+    tools?: string | undefined;
+    model?: string | undefined;
+    skipClaudeMd?: boolean | undefined;
+    force?: boolean | undefined;
+}
+/**
+ * SMI-1389: Generate a companion subagent for a skill
+ */
+declare function generateSubagent(skillPath: string, options: SubagentOptions): Promise<void>;
+interface TransformOptions {
+    dryRun?: boolean | undefined;
+    force?: boolean | undefined;
+    batch?: boolean | undefined;
+    tools?: string | undefined;
+    model?: string | undefined;
+}
+/**
+ * SMI-1390: Transform existing skill by generating subagent (non-destructive)
+ */
+declare function transformSkill(skillPath: string, options: TransformOptions): Promise<void>;
+/**
+ * Create subagent command
+ */
+export declare function createSubagentCommand(): Command;
+/**
+ * Create transform command
+ */
+export declare function createTransformCommand(): Command;
+interface McpInitOptions {
+    output?: string | undefined;
+    tools?: string | undefined;
+    force?: boolean | undefined;
+}
+/**
+ * SMI-1433: Initialize a new MCP server project
+ */
+declare function initMcpServer(name: string | undefined, options: McpInitOptions): Promise<void>;
+/**
+ * Create mcp-init command
+ */
+export declare function createMcpInitCommand(): Command;
+export { initSkill, validateSkill, publishSkill, generateSubagent, transformSkill, initMcpServer };
 //# sourceMappingURL=author.d.ts.map

package/dist/src/commands/author.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"author.d.ts","sourceRoot":"","sources":["../../../src/commands/author.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AAYnC;;GAEG;AACH,iBAAe,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyHpF;AA+BD;;GAEG;AACH,iBAAe,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA0DhE;AAED;;;GAGG;AACH,iBAAe,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAqF/D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAe3C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAa/C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAa9C;AAED,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,CAAA"}
+{"version":3,"file":"author.d.ts","sourceRoot":"","sources":["../../../src/commands/author.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AA2BnC;;GAEG;AACH,iBAAe,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAyHpF;AA+BD;;GAEG;AACH,iBAAe,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CA0DhE;AAED;;;GAGG;AACH,iBAAe,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAqF/D;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAe3C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAa/C;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAa9C;AAgGD,UAAU,eAAe;IACvB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,YAAY,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAClC,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC5B;AAED;;GAEG;AACH,iBAAe,gBAAgB,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAqI1F;AAED,UAAU,gBAAgB;IACxB,MAAM,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC5B,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CAC3B;AAED;;GAEG;AACH,iBAAe,cAAc,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAsGzF;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,OAAO,CAuB/C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,OAAO,CAuBhD;AAED,UAAU,cAAc;IACtB,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,KAAK,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CAC5B;AAED;;GAEG;AACH,iBAAe,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC,CAkK7F;AAED;;GAEG;AACH,wBAAgB,oBAAoB,IAAI,OAAO,CAqB9C;AAED,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,YAAY,EAAE,gBAAgB,EAAE,cAAc,EAAE,aAAa,EAAE,CAAA"}

package/dist/src/commands/author.js

@@ -8,11 +8,14 @@ import { input, confirm, select } from '@inquirer/prompts';
 import chalk from 'chalk';
 import ora from 'ora';
 import { mkdir, writeFile, readFile, stat } from 'fs/promises';
-import { join, resolve } from 'path';
+import { dirname, join, resolve } from 'path';
 import { createHash } from 'crypto';
 import { SkillParser } from '@skillsmith/core';
-import { SKILL_MD_TEMPLATE, README_MD_TEMPLATE } from '../templates/index.js';
+import { SKILL_MD_TEMPLATE, README_MD_TEMPLATE, renderSubagentTemplate, renderClaudeMdSnippet, renderMcpServerTemplates, } from '../templates/index.js';
 import { sanitizeError } from '../utils/sanitize.js';
+import { analyzeToolRequirements, formatToolList, parseToolsString, validateTools, } from '../utils/tool-analyzer.js';
+import { homedir } from 'os';
+import { access } from 'fs/promises';
 /**
  * Initialize a new skill directory
  */
@@ -215,7 +218,7 @@ async function publishSkill(skillPath) {
         try {
             const stats = await stat(dirPath);
             if (!stats.isDirectory()) {
-                dirPath = join(dirPath, '..');
+                dirPath = dirname(dirPath);
             }
         }
         catch {
@@ -333,5 +336,522 @@ export function createPublishCommand() {
         }
     });
 }
-export { initSkill, validateSkill, publishSkill };
+/**
+ * SMI-1389: Extract trigger phrases from skill description
+ */
+function extractTriggerPhrases(description) {
+    const phrases = [];
+    // Pattern: "Use when [phrases]" or "when the user asks to [phrases]"
+    const patterns = [
+        /use when (?:the user asks to )?["']([^"']+)["']/gi,
+        /when (?:the user asks to )?["']([^"']+)["']/gi,
+        /trigger(?:ed)? (?:by|when|phrases?)[\s:]+["']([^"']+)["']/gi,
+        /invoke when (?:the user )?["']([^"']+)["']/gi,
+    ];
+    for (const pattern of patterns) {
+        const matches = description.matchAll(pattern);
+        for (const match of matches) {
+            if (match[1]) {
+                phrases.push(match[1]);
+            }
+        }
+    }
+    return phrases;
+}
+/**
+ * SMI-1389: Validate subagent definition structure
+ */
+function validateSubagentDefinition(content) {
+    const errors = [];
+    const warnings = [];
+    // Check for YAML frontmatter
+    if (!content.trim().startsWith('---')) {
+        errors.push('Missing YAML frontmatter');
+    }
+    // Extract and validate frontmatter
+    const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (frontmatterMatch) {
+        const frontmatter = frontmatterMatch[1] || '';
+        const requiredFields = ['name', 'description', 'skills', 'tools', 'model'];
+        for (const field of requiredFields) {
+            if (!frontmatter.includes(`${field}:`)) {
+                errors.push(`Missing required field: ${field}`);
+            }
+        }
+    }
+    else {
+        errors.push('Could not parse YAML frontmatter');
+    }
+    // Check for operating protocol section
+    if (!content.includes('## Operating Protocol')) {
+        warnings.push('Missing Operating Protocol section');
+    }
+    // Check for output format section
+    if (!content.includes('## Output Format')) {
+        warnings.push('Missing Output Format section');
+    }
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings,
+    };
+}
+/**
+ * Ensure ~/.claude/agents directory exists
+ */
+async function ensureAgentsDirectory(customPath) {
+    const agentsDir = customPath
+        ? resolve(customPath.replace(/^~/, homedir()))
+        : join(homedir(), '.claude', 'agents');
+    await mkdir(agentsDir, { recursive: true });
+    return agentsDir;
+}
+/**
+ * Check if file exists
+ */
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * SMI-1389: Generate a companion subagent for a skill
+ */
+async function generateSubagent(skillPath, options) {
+    const spinner = ora('Generating subagent...').start();
+    try {
+        // Resolve skill path
+        let dirPath = resolve(skillPath || '.');
+        let skillMdPath;
+        // Check if it's a directory or file
+        try {
+            const stats = await stat(dirPath);
+            if (stats.isDirectory()) {
+                skillMdPath = join(dirPath, 'SKILL.md');
+            }
+            else {
+                skillMdPath = dirPath;
+                dirPath = dirname(dirPath);
+            }
+        }
+        catch {
+            // Try adding SKILL.md
+            skillMdPath = dirPath.endsWith('.md') ? dirPath : join(dirPath, 'SKILL.md');
+        }
+        // Read and parse SKILL.md
+        spinner.text = 'Reading SKILL.md...';
+        const content = await readFile(skillMdPath, 'utf-8');
+        const parser = new SkillParser({ requireName: true });
+        const { validation, metadata } = parser.parseWithValidation(content);
+        if (!validation.valid || !metadata) {
+            spinner.fail('SKILL.md validation failed');
+            printValidationResult(validation, skillMdPath);
+            return;
+        }
+        // Analyze tool requirements
+        spinner.text = 'Analyzing tool requirements...';
+        const toolAnalysis = analyzeToolRequirements(content);
+        // Override tools if specified
+        let tools = toolAnalysis.requiredTools;
+        if (options.tools) {
+            const customTools = parseToolsString(options.tools);
+            const validation = validateTools(customTools);
+            if (!validation.valid) {
+                spinner.fail(`Unrecognized tools: ${validation.unrecognized.join(', ')}`);
+                return;
+            }
+            tools = customTools;
+        }
+        // Extract trigger phrases
+        const triggerPhrases = extractTriggerPhrases(metadata.description || '');
+        // Determine model
+        const model = options.model || 'sonnet';
+        if (!['sonnet', 'opus', 'haiku'].includes(model)) {
+            spinner.fail(`Invalid model: ${model}. Must be sonnet, opus, or haiku.`);
+            return;
+        }
+        // Generate subagent content
+        spinner.text = 'Generating subagent definition...';
+        const subagentContent = renderSubagentTemplate({
+            skillName: metadata.name,
+            description: metadata.description || `Specialist for ${metadata.name}`,
+            triggerPhrases,
+            tools,
+            model,
+        });
+        // Validate generated content
+        const subagentValidation = validateSubagentDefinition(subagentContent);
+        if (!subagentValidation.valid) {
+            spinner.fail('Generated subagent is invalid');
+            console.log(chalk.red('\nGeneration errors:'));
+            for (const error of subagentValidation.errors) {
+                console.log(chalk.red(`  - ${error}`));
+            }
+            return;
+        }
+        // Ensure agents directory exists
+        const agentsDir = await ensureAgentsDirectory(options.output);
+        const subagentPath = join(agentsDir, `${metadata.name}-specialist.md`);
+        // Check if subagent already exists
+        if (await fileExists(subagentPath)) {
+            if (!options.force) {
+                spinner.warn(`Subagent already exists: ${subagentPath}`);
+                console.log(chalk.yellow('  Use --force to overwrite'));
+                return;
+            }
+        }
+        // Write subagent file
+        await writeFile(subagentPath, subagentContent, 'utf-8');
+        spinner.succeed(`Generated subagent: ${subagentPath}`);
+        // Show tool analysis
+        console.log(chalk.bold('\nTool Analysis:'));
+        console.log(chalk.dim(`  Confidence: ${toolAnalysis.confidence}`));
+        console.log(chalk.dim(`  Tools: ${formatToolList(tools)}`));
+        if (toolAnalysis.detectedPatterns.length > 0) {
+            console.log(chalk.dim('  Detected patterns:'));
+            for (const pattern of toolAnalysis.detectedPatterns.slice(0, 5)) {
+                console.log(chalk.dim(`    - ${pattern}`));
+            }
+        }
+        // Generate and display CLAUDE.md snippet
+        if (!options.skipClaudeMd) {
+            const snippet = renderClaudeMdSnippet({
+                skillName: metadata.name,
+                description: metadata.description || '',
+                triggerPhrases,
+                tools,
+                model,
+            });
+            console.log(chalk.bold('\nCLAUDE.md Integration Snippet:'));
+            console.log(chalk.cyan('─'.repeat(50)));
+            console.log(snippet);
+            console.log(chalk.cyan('─'.repeat(50)));
+            console.log(chalk.dim('\nAdd this snippet to your project CLAUDE.md to enable delegation.'));
+        }
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(`Failed to generate subagent: ${sanitizeError(error)}`);
+        throw error;
+    }
+}
+/**
+ * SMI-1390: Transform existing skill by generating subagent (non-destructive)
+ */
+async function transformSkill(skillPath, options) {
+    const spinner = ora('Transforming skill...').start();
+    try {
+        const dirPath = resolve(skillPath || '.');
+        // Check if batch mode
+        if (options.batch) {
+            spinner.text = 'Scanning for skills...';
+            const entries = await readFile(dirPath, 'utf-8').catch(() => null);
+            if (entries === null) {
+                // It's a directory, scan for subdirectories with SKILL.md
+                const { readdir } = await import('fs/promises');
+                const subdirs = await readdir(dirPath, { withFileTypes: true });
+                const skillDirs = [];
+                for (const entry of subdirs) {
+                    if (entry.isDirectory()) {
+                        const skillMdPath = join(dirPath, entry.name, 'SKILL.md');
+                        if (await fileExists(skillMdPath)) {
+                            skillDirs.push(join(dirPath, entry.name));
+                        }
+                    }
+                }
+                if (skillDirs.length === 0) {
+                    spinner.warn('No skills found in directory');
+                    return;
+                }
+                spinner.succeed(`Found ${skillDirs.length} skills`);
+                // Process each skill
+                for (const skillDir of skillDirs) {
+                    console.log(chalk.dim(`\nProcessing: ${skillDir}`));
+                    await transformSkill(skillDir, {
+                        ...options,
+                        batch: false, // Don't recurse
+                    });
+                }
+                return;
+            }
+        }
+        // Single skill transform
+        const skillMdPath = join(dirPath, 'SKILL.md');
+        if (!(await fileExists(skillMdPath))) {
+            spinner.fail(`No SKILL.md found at: ${skillMdPath}`);
+            return;
+        }
+        // Read and parse
+        spinner.text = 'Reading SKILL.md...';
+        const content = await readFile(skillMdPath, 'utf-8');
+        const parser = new SkillParser({ requireName: true });
+        const { validation, metadata } = parser.parseWithValidation(content);
+        if (!validation.valid || !metadata) {
+            spinner.fail('SKILL.md validation failed');
+            printValidationResult(validation, skillMdPath);
+            return;
+        }
+        // Check if subagent already exists
+        const agentsDir = join(homedir(), '.claude', 'agents');
+        const subagentPath = join(agentsDir, `${metadata.name}-specialist.md`);
+        if (await fileExists(subagentPath)) {
+            if (!options.force) {
+                spinner.warn(`Subagent already exists: ${subagentPath}`);
+                console.log(chalk.yellow('  Use --force to overwrite'));
+                return;
+            }
+        }
+        if (options.dryRun) {
+            spinner.succeed('Dry run - would generate:');
+            console.log(chalk.dim(`  Subagent: ${subagentPath}`));
+            // Show tool analysis
+            const toolAnalysis = analyzeToolRequirements(content);
+            console.log(chalk.dim(`  Tools: ${formatToolList(toolAnalysis.requiredTools)}`));
+            console.log(chalk.dim(`  Confidence: ${toolAnalysis.confidence}`));
+            return;
+        }
+        spinner.stop();
+        // Generate subagent using existing function
+        await generateSubagent(dirPath, {
+            force: options.force,
+            tools: options.tools,
+            model: options.model,
+            skipClaudeMd: false,
+        });
+    }
+    catch (error) {
+        spinner.fail(`Failed to transform skill: ${sanitizeError(error)}`);
+        throw error;
+    }
+}
+/**
+ * Create subagent command
+ */
+export function createSubagentCommand() {
+    return new Command('subagent')
+        .description('Generate a companion subagent for a skill')
+        .argument('[path]', 'Path to skill directory', '.')
+        .option('-o, --output <path>', 'Output directory', '~/.claude/agents')
+        .option('--tools <tools>', 'Override detected tools (comma-separated)')
+        .option('--model <model>', 'Model for subagent: sonnet|opus|haiku', 'sonnet')
+        .option('--skip-claude-md', 'Skip CLAUDE.md snippet generation')
+        .option('--force', 'Overwrite existing subagent definition')
+        .action(async (skillPath, opts) => {
+        try {
+            await generateSubagent(skillPath, {
+                output: opts['output'],
+                tools: opts['tools'],
+                model: opts['model'],
+                skipClaudeMd: opts['skipClaudeMd'],
+                force: opts['force'],
+            });
+        }
+        catch (error) {
+            console.error(chalk.red('Error generating subagent:'), sanitizeError(error));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * Create transform command
+ */
+export function createTransformCommand() {
+    return new Command('transform')
+        .description('Upgrade existing skill with subagent configuration')
+        .argument('[path]', 'Path to skill directory', '.')
+        .option('--dry-run', 'Preview what would be generated')
+        .option('--force', 'Overwrite existing subagent')
+        .option('--batch', 'Process directory of skills')
+        .option('--tools <tools>', 'Override detected tools (comma-separated)')
+        .option('--model <model>', 'Model for subagent: sonnet|opus|haiku', 'sonnet')
+        .action(async (skillPath, opts) => {
+        try {
+            await transformSkill(skillPath, {
+                dryRun: opts['dryRun'],
+                force: opts['force'],
+                batch: opts['batch'],
+                tools: opts['tools'],
+                model: opts['model'],
+            });
+        }
+        catch (error) {
+            console.error(chalk.red('Error transforming skill:'), sanitizeError(error));
+            process.exit(1);
+        }
+    });
+}
+/**
+ * SMI-1433: Initialize a new MCP server project
+ */
+async function initMcpServer(name, options) {
+    // Interactive prompts if name not provided
+    const serverName = name ||
+        (await input({
+            message: 'MCP server name:',
+            validate: (value) => {
+                if (!value.trim())
+                    return 'Name is required';
+                if (!/^[a-z][a-z0-9-]*$/.test(value)) {
+                    return 'Name must be lowercase, start with a letter, and contain only letters, numbers, and hyphens';
+                }
+                return true;
+            },
+        }));
+    const description = await input({
+        message: 'Description:',
+        default: `An MCP server for ${serverName}`,
+    });
+    const author = await input({
+        message: 'Author:',
+        default: process.env['USER'] || 'author',
+    });
+    // Parse initial tools if provided
+    const initialTools = [];
+    const toolNameRegex = /^[a-z][a-z0-9_-]*$/;
+    if (options.tools) {
+        const toolNames = options.tools
+            .split(',')
+            .map((t) => t.trim())
+            .filter((t) => t.length > 0);
+        for (const toolName of toolNames) {
+            if (!toolNameRegex.test(toolName)) {
+                console.log(chalk.red(`Invalid tool name: ${toolName}. Must be lowercase, start with a letter, and contain only letters, numbers, underscores, and hyphens.`));
+                return;
+            }
+            initialTools.push({
+                name: toolName,
+                description: `${toolName} tool`,
+                parameters: [],
+            });
+        }
+    }
+    // Ask about tools if none specified
+    if (initialTools.length === 0) {
+        const addTools = await confirm({
+            message: 'Would you like to define initial tools interactively?',
+            default: false,
+        });
+        if (addTools) {
+            let addMore = true;
+            while (addMore) {
+                const toolName = await input({
+                    message: 'Tool name:',
+                    validate: (value) => {
+                        if (!value.trim())
+                            return 'Tool name is required';
+                        if (!/^[a-z][a-z0-9_-]*$/.test(value)) {
+                            return 'Tool name must be lowercase with letters, numbers, underscores, and hyphens';
+                        }
+                        return true;
+                    },
+                });
+                const toolDescription = await input({
+                    message: 'Tool description:',
+                    default: `${toolName} tool`,
+                });
+                initialTools.push({
+                    name: toolName,
+                    description: toolDescription,
+                    parameters: [],
+                });
+                addMore = await confirm({
+                    message: 'Add another tool?',
+                    default: false,
+                });
+            }
+        }
+    }
+    const targetDir = options.output ? resolve(options.output) : resolve('.', serverName);
+    // Check if directory already exists
+    try {
+        await stat(targetDir);
+        if (!options.force) {
+            const overwrite = await confirm({
+                message: `Directory ${targetDir} already exists. Overwrite?`,
+                default: false,
+            });
+            if (!overwrite) {
+                console.log(chalk.yellow('Initialization cancelled'));
+                return;
+            }
+        }
+    }
+    catch {
+        // Directory doesn't exist, continue
+    }
+    const spinner = ora('Creating MCP server...').start();
+    try {
+        // Generate templates
+        const files = renderMcpServerTemplates({
+            name: serverName,
+            description,
+            tools: initialTools,
+            author,
+        });
+        // Create directory structure
+        await mkdir(targetDir, { recursive: true });
+        await mkdir(join(targetDir, 'src'), { recursive: true });
+        await mkdir(join(targetDir, 'src', 'tools'), { recursive: true });
+        // Write all files
+        for (const [filePath, content] of files) {
+            const fullPath = join(targetDir, filePath);
+            const dir = dirname(fullPath);
+            await mkdir(dir, { recursive: true });
+            await writeFile(fullPath, content, 'utf-8');
+        }
+        spinner.succeed(`Created MCP server at ${targetDir}`);
+        console.log(chalk.bold('\nNext steps:'));
+        console.log(chalk.dim(`  1. cd ${targetDir}`));
+        console.log(chalk.dim('  2. npm install'));
+        console.log(chalk.dim('  3. npm run dev  # Run in development mode'));
+        console.log(chalk.dim('  4. Edit src/tools/ to add your tool implementations'));
+        console.log();
+        console.log(chalk.bold('Configure in Claude Code:'));
+        console.log(chalk.cyan('─'.repeat(50)));
+        console.log(chalk.dim(`Add to ~/.claude/settings.json:`));
+        console.log(chalk.white(`{
+  "mcpServers": {
+    "${serverName}": {
+      "command": "npx",
+      "args": ["tsx", "${join(targetDir, 'src', 'index.ts')}"]
+    }
+  }
+}`));
+        console.log(chalk.cyan('─'.repeat(50)));
+        console.log();
+    }
+    catch (error) {
+        spinner.fail(`Failed to create MCP server: ${sanitizeError(error)}`);
+        throw error;
+    }
+}
+/**
+ * Create mcp-init command
+ */
+export function createMcpInitCommand() {
+    return new Command('mcp-init')
+        .description('Scaffold a new MCP server project')
+        .argument('[name]', 'MCP server name')
+        .option('-o, --output <path>', 'Output directory')
+        .option('--tools <tools>', 'Initial tools (comma-separated)')
+        .option('--force', 'Overwrite existing directory')
+        .action(async (name, opts) => {
+        try {
+            await initMcpServer(name, {
+                output: opts['output'],
+                tools: opts['tools'],
+                force: opts['force'],
+            });
+        }
+        catch (error) {
+            console.error(chalk.red('Error creating MCP server:'), sanitizeError(error));
+            process.exit(1);
+        }
+    });
+}
+export { initSkill, validateSkill, publishSkill, generateSubagent, transformSkill, initMcpServer };
 //# sourceMappingURL=author.js.map