@neural-tools/cli 0.1.0

package/LICENSE.md

@@ -0,0 +1,80 @@
+# Neural Tools License
+
+Copyright (c) 2025 Luke Amy. All rights reserved.
+
+## License Agreement
+
+This software is provided under a dual-license model:
+
+### 1. Free Tier License (MIT)
+
+The following components are licensed under the MIT License:
+
+- Basic MCP generation functionality
+- Claude command generation
+- Core utilities and types
+- Basic templates
+- Documentation and examples
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of the free tier components to use, copy, modify, merge, publish, and distribute, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+### 2. Pro/Enterprise License (Proprietary)
+
+The following features require a valid Pro or Enterprise license:
+
+**Pro Features:**
+- Vector database integration
+- Semantic caching
+- Fine-tuning workflows
+- Cloud deployment templates (AWS/GCP)
+- Premium templates and examples
+- GitHub automation features
+
+**Enterprise Features:**
+- White-label support
+- Custom integrations
+- Priority support
+- SLA guarantees
+- Team collaboration features
+
+These features are proprietary and may not be used without a valid license key purchased from neural-tools.dev.
+
+### License Terms
+
+1. **Free Tier**: You may use the free tier features for any purpose, including commercial use, under the MIT License terms.
+
+2. **Pro/Enterprise**: You must purchase a license to access Pro or Enterprise features. Each license is:
+   - Per-user for individual licenses
+   - Per-organization for team/enterprise licenses
+   - Non-transferable without written consent
+   - Subject to the terms at neural-tools.dev/terms
+
+3. **Source Code**: This repository is private. You may not:
+   - Redistribute the source code
+   - Create derivative works for redistribution
+   - Reverse engineer Pro/Enterprise features
+   - Remove or circumvent license checks
+
+4. **Support**: Support is provided based on your license tier:
+   - Free: Community support only
+   - Pro: Email support (48-hour response)
+   - Enterprise: Priority support with SLA
+
+### Warranty Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+### Contact
+
+For licensing inquiries:
+- Email: licensing@neural-tools.dev
+- Website: https://neural-tools.dev/pricing
+- Support: support@neural-tools.dev
+
+---
+
+**Last Updated:** January 2025

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const core_1 = require("@neural-tools/core");
+const generate_mcp_1 = require("./commands/generate-mcp");
+const generate_command_1 = require("./commands/generate-command");
+const generate_agent_1 = require("./commands/generate-agent");
+const deploy_1 = require("./commands/deploy");
+const login_1 = require("./commands/login");
+const status_1 = require("./commands/status");
+const program = new commander_1.Command();
+program
+    .name('neural-tools')
+    .description('Neural Tools - Build MCPs, Claude commands, and AI workflows')
+    .version('0.1.0');
+// Generate commands
+const generate = program
+    .command('generate')
+    .alias('g')
+    .description('Generate new components (MCP, command, agent, etc.)');
+generate
+    .command('mcp')
+    .description('Generate a new MCP server')
+    .argument('<name>', 'Name of the MCP server')
+    .option('-d, --description <desc>', 'Description of the MCP')
+    .option('-o, --output <dir>', 'Output directory', './apps')
+    .option('--fastmcp', 'Use FastMCP template', true)
+    .option('--cicd <provider>', 'CI/CD provider (github, harness, none)', 'github')
+    .option('--deployment <platform>', 'Deployment platform (aws, gcp, none)', 'aws')
+    .option('--dry-run', 'Preview without creating files', false)
+    .action(generate_mcp_1.generateMCP);
+generate
+    .command('command')
+    .description('Generate a new Claude command')
+    .argument('<name>', 'Name of the command (without /)')
+    .option('-d, --description <desc>', 'Description of the command')
+    .option('-o, --output <dir>', 'Output directory', './claude/commands')
+    .option('--args <arguments...>', 'Command arguments')
+    .option('--tools <tools...>', 'Allowed tools')
+    .option('--global', 'Install globally to ~/.claude/commands', false)
+    .option('--dry-run', 'Preview without creating files', false)
+    .action(generate_command_1.generateCommand);
+generate
+    .command('agent')
+    .description('Generate a new Claude agent')
+    .argument('<name>', 'Name of the agent')
+    .option('-d, --description <desc>', 'Description of the agent')
+    .option('-o, --output <dir>', 'Output directory', './claude/agents')
+    .option('--model <model>', 'Model to use (sonnet, opus, haiku)', 'sonnet')
+    .option('--tools <tools...>', 'Available tools')
+    .option('--global', 'Install globally to ~/.claude/agents', false)
+    .option('--dry-run', 'Preview without creating files', false)
+    .action(generate_agent_1.generateAgent);
+// Deploy command
+program
+    .command('deploy')
+    .description('Deploy an MCP server')
+    .argument('<name>', 'Name of the MCP to deploy')
+    .option('-p, --platform <platform>', 'Deployment platform (aws, gcp)', 'aws')
+    .option('--region <region>', 'AWS/GCP region')
+    .option('--env <env>', 'Environment (dev, staging, prod)', 'dev')
+    .action(deploy_1.deployMCP);
+// License management
+program
+    .command('login')
+    .description('Authenticate and manage your license')
+    .option('--key <key>', 'License key')
+    .action(login_1.loginCommand);
+program
+    .command('status')
+    .description('Show license status and available features')
+    .action(status_1.statusCommand);
+// Error handling
+program.exitOverride();
+try {
+    program.parse(process.argv);
+}
+catch (error) {
+    if (error.code !== 'commander.help' && error.code !== 'commander.version') {
+        core_1.logger.error(error.message || 'An unexpected error occurred');
+        process.exit(1);
+    }
+}

package/dist/commands/deploy.d.ts

@@ -0,0 +1,7 @@
+interface DeployOptions {
+    platform?: 'aws' | 'gcp';
+    region?: string;
+    env?: string;
+}
+export declare function deployMCP(name: string, options: DeployOptions): Promise<void>;
+export {};

package/dist/commands/deploy.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deployMCP = deployMCP;
+const core_1 = require("@neural-tools/core");
+const execa_1 = require("execa");
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+async function deployMCP(name, options) {
+    core_1.logger.header(`Deploying MCP: ${name}`);
+    // Check license for cloud deployment
+    await (0, core_1.requireFeature)('cloud-deployment', 'Cloud Deployment');
+    const platform = options.platform || 'aws';
+    const env = options.env || 'dev';
+    core_1.logger.info(`Platform: ${platform}`);
+    core_1.logger.info(`Environment: ${env}`);
+    // Find MCP directory
+    const mcpDir = path_1.default.resolve('./apps', name);
+    if (!await fs_extra_1.default.pathExists(mcpDir)) {
+        throw new Error(`MCP "${name}" not found at ${mcpDir}`);
+    }
+    core_1.logger.startSpinner('Building MCP...');
+    try {
+        // Build the MCP
+        await (0, execa_1.execa)('npm', ['run', 'build'], { cwd: mcpDir, stdio: 'pipe' });
+        core_1.logger.succeedSpinner('MCP built successfully');
+        if (platform === 'aws') {
+            await deployToAWS(name, mcpDir, options);
+        }
+        else if (platform === 'gcp') {
+            await deployToGCP(name, mcpDir, options);
+        }
+        core_1.logger.success(`✨ MCP "${name}" deployed successfully!`);
+    }
+    catch (error) {
+        core_1.logger.failSpinner('Deployment failed');
+        throw error;
+    }
+}
+async function deployToAWS(name, mcpDir, options) {
+    core_1.logger.startSpinner('Deploying to AWS Lambda...');
+    // TODO: Implement AWS Lambda deployment
+    // This would use AWS CDK or SAM to deploy
+    // For now, just a placeholder
+    core_1.logger.updateSpinner('Packaging Lambda function...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    core_1.logger.updateSpinner('Uploading to S3...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    core_1.logger.updateSpinner('Creating/updating Lambda function...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    core_1.logger.succeedSpinner('Deployed to AWS Lambda');
+    core_1.logger.section('Deployment Info', [
+        `Function: ${name}-${options.env}`,
+        `Region: ${options.region || 'us-east-1'}`,
+        `Environment: ${options.env}`,
+        '',
+        'Configure in Claude Code:',
+        JSON.stringify({
+            mcpServers: {
+                [name]: {
+                    command: 'aws',
+                    args: [
+                        'lambda',
+                        'invoke',
+                        '--function-name',
+                        `${name}-${options.env}`,
+                        '--payload',
+                        'stdin',
+                        '--output',
+                        'stdout'
+                    ]
+                }
+            }
+        }, null, 2)
+    ]);
+}
+async function deployToGCP(name, mcpDir, options) {
+    core_1.logger.startSpinner('Deploying to Google Cloud Functions...');
+    // TODO: Implement GCP Cloud Functions deployment
+    // This would use gcloud CLI or Terraform
+    // For now, just a placeholder
+    core_1.logger.updateSpinner('Packaging function...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    core_1.logger.updateSpinner('Uploading to Cloud Storage...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    core_1.logger.updateSpinner('Deploying Cloud Function...');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    core_1.logger.succeedSpinner('Deployed to Google Cloud Functions');
+    core_1.logger.section('Deployment Info', [
+        `Function: ${name}-${options.env}`,
+        `Region: ${options.region || 'us-central1'}`,
+        `Environment: ${options.env}`
+    ]);
+}

package/dist/commands/generate-agent.d.ts

@@ -0,0 +1,10 @@
+interface GenerateAgentOptions {
+    description?: string;
+    output?: string;
+    model?: 'sonnet' | 'opus' | 'haiku';
+    tools?: string[];
+    global?: boolean;
+    dryRun?: boolean;
+}
+export declare function generateAgent(name: string, options: GenerateAgentOptions): Promise<void>;
+export {};

package/dist/commands/generate-agent.js

@@ -0,0 +1,126 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateAgent = generateAgent;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const core_1 = require("@neural-tools/core");
+const inquirer_1 = __importDefault(require("inquirer"));
+async function generateAgent(name, options) {
+    core_1.logger.header(`Generating Claude Agent: ${name}`);
+    // Prompt for missing information
+    let description = options.description;
+    if (!description) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description of your agent:',
+                default: `${name} specialized agent`
+            }
+        ]);
+        description = answers.description;
+    }
+    // Determine output directory
+    let outputDir;
+    if (options.global) {
+        outputDir = path_1.default.join(os_1.default.homedir(), '.claude', 'agents');
+    }
+    else {
+        outputDir = path_1.default.resolve(options.output || './claude/agents');
+    }
+    const agentFile = path_1.default.join(outputDir, `${name}.md`);
+    const model = options.model || 'sonnet';
+    if (options.dryRun) {
+        core_1.logger.info('Dry run mode - no files will be created');
+        core_1.logger.section('Configuration', [
+            `Name: ${name}`,
+            `Description: ${description}`,
+            `Output: ${agentFile}`,
+            `Model: ${model}`,
+            `Tools: ${options.tools?.join(', ') || 'all'}`,
+            `Global: ${options.global ? 'Yes' : 'No'}`
+        ]);
+        return;
+    }
+    // Check if file already exists
+    if (await fs_extra_1.default.pathExists(agentFile)) {
+        const { overwrite } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Agent ${name} already exists. Overwrite?`,
+                default: false
+            }
+        ]);
+        if (!overwrite) {
+            core_1.logger.warn('Cancelled');
+            return;
+        }
+    }
+    core_1.logger.startSpinner('Creating Claude agent...');
+    try {
+        await fs_extra_1.default.ensureDir(outputDir);
+        // Build frontmatter
+        const frontmatter = ['---'];
+        frontmatter.push(`model: claude-${model}-4-5`);
+        if (options.tools && options.tools.length > 0) {
+            frontmatter.push(`tools:`);
+            options.tools.forEach(tool => {
+                frontmatter.push(`  - ${tool}`);
+            });
+        }
+        frontmatter.push('---');
+        frontmatter.push('');
+        // Build agent content
+        const agentContent = `${frontmatter.join('\n')}# ${name} Agent
+
+${description}
+
+## Role
+
+You are a specialized agent for ${name} tasks. Your primary responsibilities include:
+
+- [Responsibility 1]
+- [Responsibility 2]
+- [Responsibility 3]
+
+## Guidelines
+
+When performing ${name} tasks:
+
+1. [Guideline 1]
+2. [Guideline 2]
+3. [Guideline 3]
+
+## Output Format
+
+Provide clear, structured responses that:
+- [Output requirement 1]
+- [Output requirement 2]
+- [Output requirement 3]
+
+Focus on ${name} and deliver actionable results.
+`;
+        await fs_extra_1.default.writeFile(agentFile, agentContent, 'utf-8');
+        core_1.logger.succeedSpinner('Claude agent created successfully!');
+        core_1.logger.section('Next steps', [
+            options.global
+                ? `Agent ${name} is now available globally in Claude Code`
+                : `Add the agent to your project by copying ${agentFile}`,
+            '',
+            'Customize the agent by editing:',
+            `  ${agentFile}`,
+            '',
+            'Use the agent via the Task tool in Claude Code'
+        ]);
+        core_1.logger.success(`✨ Agent "${name}" ready to use!`);
+    }
+    catch (error) {
+        core_1.logger.failSpinner('Failed to create agent');
+        throw error;
+    }
+}

package/dist/commands/generate-command.d.ts

@@ -0,0 +1,10 @@
+interface GenerateCommandOptions {
+    description?: string;
+    output?: string;
+    args?: string[];
+    tools?: string[];
+    global?: boolean;
+    dryRun?: boolean;
+}
+export declare function generateCommand(name: string, options: GenerateCommandOptions): Promise<void>;
+export {};

package/dist/commands/generate-command.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateCommand = generateCommand;
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const core_1 = require("@neural-tools/core");
+const inquirer_1 = __importDefault(require("inquirer"));
+async function generateCommand(name, options) {
+    core_1.logger.header(`Generating Claude Command: /${name}`);
+    // Prompt for missing information
+    let description = options.description;
+    if (!description) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description of your command:',
+                default: `Execute ${name}`
+            }
+        ]);
+        description = answers.description;
+    }
+    // Determine output directory
+    let outputDir;
+    if (options.global) {
+        outputDir = path_1.default.join(os_1.default.homedir(), '.claude', 'commands');
+    }
+    else {
+        outputDir = path_1.default.resolve(options.output || './claude/commands');
+    }
+    const commandFile = path_1.default.join(outputDir, `${name}.md`);
+    if (options.dryRun) {
+        core_1.logger.info('Dry run mode - no files will be created');
+        core_1.logger.section('Configuration', [
+            `Name: /${name}`,
+            `Description: ${description}`,
+            `Output: ${commandFile}`,
+            `Arguments: ${options.args?.join(', ') || 'none'}`,
+            `Allowed Tools: ${options.tools?.join(', ') || 'all'}`,
+            `Global: ${options.global ? 'Yes' : 'No'}`
+        ]);
+        return;
+    }
+    // Check if file already exists
+    if (await fs_extra_1.default.pathExists(commandFile)) {
+        const { overwrite } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Command /${name} already exists. Overwrite?`,
+                default: false
+            }
+        ]);
+        if (!overwrite) {
+            core_1.logger.warn('Cancelled');
+            return;
+        }
+    }
+    core_1.logger.startSpinner('Creating Claude command...');
+    try {
+        await fs_extra_1.default.ensureDir(outputDir);
+        // Build frontmatter
+        const frontmatter = ['---'];
+        if (options.args && options.args.length > 0) {
+            frontmatter.push(`argument-hint: ${options.args.join(' ')}`);
+        }
+        frontmatter.push(`description: ${description}`);
+        if (options.tools && options.tools.length > 0) {
+            frontmatter.push(`allowed-tools:`);
+            options.tools.forEach(tool => {
+                frontmatter.push(`  - ${tool}`);
+            });
+        }
+        frontmatter.push('---');
+        frontmatter.push('');
+        // Build command content
+        const argsList = options.args || [];
+        const argPlaceholders = argsList.map((arg, i) => `$${i + 1}`).join(' ');
+        const argDescription = argsList.length > 0
+            ? `\n\nArguments:\n${argsList.map((arg, i) => `- $${i + 1}: ${arg}`).join('\n')}`
+            : '';
+        const commandContent = `${frontmatter.join('\n')}# ${name} Command
+
+Execute the ${name} operation${argDescription ? ':' + argDescription : '.'}
+
+${argPlaceholders ? `Using arguments: ${argPlaceholders}` : ''}
+
+Please proceed with the ${name} operation.
+`;
+        await fs_extra_1.default.writeFile(commandFile, commandContent, 'utf-8');
+        core_1.logger.succeedSpinner('Claude command created successfully!');
+        core_1.logger.section('Next steps', [
+            options.global
+                ? `Command /${name} is now available globally in Claude Code`
+                : `Add the command to your project by copying ${commandFile}`,
+            '',
+            'Usage:',
+            argsList.length > 0
+                ? `  /${name} ${argsList.join(' ')}`
+                : `  /${name}`
+        ]);
+        core_1.logger.success(`✨ Command "/${name}" ready to use!`);
+    }
+    catch (error) {
+        core_1.logger.failSpinner('Failed to create command');
+        throw error;
+    }
+}

package/dist/commands/generate-mcp.d.ts

@@ -0,0 +1,10 @@
+interface GenerateMCPOptions {
+    description?: string;
+    output?: string;
+    fastmcp?: boolean;
+    cicd?: 'github' | 'harness' | 'none';
+    deployment?: 'aws' | 'gcp' | 'none';
+    dryRun?: boolean;
+}
+export declare function generateMCP(name: string, options: GenerateMCPOptions): Promise<void>;
+export {};

package/dist/commands/generate-mcp.js

@@ -0,0 +1,429 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMCP = generateMCP;
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const core_1 = require("@neural-tools/core");
+const inquirer_1 = __importDefault(require("inquirer"));
+async function generateMCP(name, options) {
+    core_1.logger.header(`Generating MCP: ${name}`);
+    // Check license for cloud deployment
+    if (options.deployment !== 'none') {
+        await (0, core_1.requireFeature)('cloud-deployment', 'Cloud Deployment');
+    }
+    // Prompt for missing information
+    let description = options.description;
+    if (!description) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'description',
+                message: 'Description of your MCP:',
+                default: `${name} MCP server`
+            }
+        ]);
+        description = answers.description;
+    }
+    const outputDir = path_1.default.resolve(options.output || './apps', name);
+    if (options.dryRun) {
+        core_1.logger.info('Dry run mode - no files will be created');
+        core_1.logger.section('Configuration', [
+            `Name: ${name}`,
+            `Description: ${description}`,
+            `Output: ${outputDir}`,
+            `Template: ${options.fastmcp ? 'FastMCP' : 'Standard'}`,
+            `CI/CD: ${options.cicd}`,
+            `Deployment: ${options.deployment}`
+        ]);
+        return;
+    }
+    // Check if directory already exists
+    if (await fs_extra_1.default.pathExists(outputDir)) {
+        const { overwrite } = await inquirer_1.default.prompt([
+            {
+                type: 'confirm',
+                name: 'overwrite',
+                message: `Directory ${outputDir} already exists. Overwrite?`,
+                default: false
+            }
+        ]);
+        if (!overwrite) {
+            core_1.logger.warn('Cancelled');
+            return;
+        }
+        await fs_extra_1.default.remove(outputDir);
+    }
+    core_1.logger.startSpinner('Creating MCP structure...');
+    try {
+        // Create directory structure
+        await fs_extra_1.default.ensureDir(outputDir);
+        // Create pyproject.toml
+        const pyprojectContent = `[project]
+name = "mcp-${name}"
+version = "0.1.0"
+description = "${description}"
+requires-python = ">=3.10"
+dependencies = [
+    "fastmcp>=2.2.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "black>=23.0.0",
+    "ruff>=0.1.0",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.black]
+line-length = 100
+
+[tool.ruff]
+line-length = 100
+`;
+        await fs_extra_1.default.writeFile(path_1.default.join(outputDir, 'pyproject.toml'), pyprojectContent, 'utf-8');
+        // Create main server.py with FastMCP
+        const serverContent = `"""
+${name} MCP Server
+
+${description}
+"""
+from fastmcp import FastMCP
+
+mcp = FastMCP("${name}")
+
+
+@mcp.tool()
+def add_numbers(a: int, b: int) -> int:
+    """Add two numbers together"""
+    return a + b
+
+
+@mcp.tool()
+async def process_message(message: str) -> str:
+    """Process a message and return the result"""
+    return f"Processed: {message}"
+
+
+@mcp.resource("config://version")
+def get_version() -> str:
+    """Get the current version of the MCP server"""
+    return "0.1.0"
+
+
+@mcp.resource("example://data/{item_id}")
+async def get_item(item_id: str) -> str:
+    """Get an item by ID"""
+    return f"Item data for: {item_id}"
+
+
+@mcp.prompt()
+def review_code(code: str) -> str:
+    """Generate a code review prompt"""
+    return f"""Please review this code:
+
+\`\`\`python
+{code}
+\`\`\`
+
+Provide feedback on:
+1. Code quality
+2. Potential bugs
+3. Performance improvements
+4. Best practices
+"""
+
+
+@mcp.prompt()
+def brainstorm_topic(topic: str) -> str:
+    """Generate a brainstorming prompt"""
+    return f"Let's brainstorm ideas about: {topic}"
+
+
+if __name__ == "__main__":
+    mcp.run()
+`;
+        await fs_extra_1.default.writeFile(path_1.default.join(outputDir, 'server.py'), serverContent, 'utf-8');
+        // Create README
+        const readmeContent = `# ${name} MCP Server
+
+${description}
+
+## Quick Start with Docker
+
+\`\`\`bash
+# Start the MCP server
+docker-compose up
+
+# In another terminal, test it
+docker-compose exec mcp python server.py
+\`\`\`
+
+## Local Development
+
+### Prerequisites
+
+- Python 3.10+
+- uv (recommended) or pip
+
+### Installation
+
+\`\`\`bash
+# Using uv (recommended)
+uv pip install -e .
+
+# Or using pip
+pip install -e .
+\`\`\`
+
+### Running the Server
+
+\`\`\`bash
+# Development mode with MCP Inspector
+fastmcp dev server.py
+
+# Direct execution
+python server.py
+
+# Install to Claude Desktop
+fastmcp install server.py
+\`\`\`
+
+## Usage with Claude Code
+
+Add to your Claude Code settings (\`~/.config/claude/config.json\`):
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${name}": {
+      "command": "python",
+      "args": ["/path/to/server.py"]
+    }
+  }
+}
+\`\`\`
+
+Or use the Docker container:
+
+\`\`\`json
+{
+  "mcpServers": {
+    "${name}": {
+      "command": "docker",
+      "args": ["run", "-i", "mcp-${name}"]
+    }
+  }
+}
+\`\`\`
+
+## Features
+
+- **Tools**: Add numbers, process messages
+- **Resources**: Get version, retrieve items by ID
+- **Prompts**: Code review, brainstorming
+
+## Project Structure
+
+\`\`\`
+.
+├── server.py           # Main MCP server
+├── pyproject.toml      # Python project configuration
+├── Dockerfile          # Docker image definition
+├── docker-compose.yml  # Local development setup
+└── README.md          # This file
+\`\`\`
+
+## Development
+
+### Running Tests
+
+\`\`\`bash
+pytest
+\`\`\`
+
+### Code Formatting
+
+\`\`\`bash
+black .
+ruff check .
+\`\`\`
+
+## License
+
+MIT
+`;
+        await fs_extra_1.default.writeFile(path_1.default.join(outputDir, 'README.md'), readmeContent, 'utf-8');
+        // Create Dockerfile
+        const dockerfileContent = `FROM python:3.11-slim
+
+WORKDIR /app
+
+# Install uv for faster dependency installation
+RUN pip install --no-cache-dir uv
+
+# Copy project files
+COPY pyproject.toml .
+COPY server.py .
+
+# Install dependencies
+RUN uv pip install --system --no-cache .
+
+# Run the MCP server
+CMD ["python", "server.py"]
+`;
+        await fs_extra_1.default.writeFile(path_1.default.join(outputDir, 'Dockerfile'), dockerfileContent, 'utf-8');
+        // Create docker-compose.yml
+        const dockerComposeContent = `version: '3.8'
+
+services:
+  mcp:
+    build: .
+    image: mcp-${name}
+    container_name: ${name}-mcp
+    stdin_open: true
+    tty: true
+    volumes:
+      - .:/app
+    environment:
+      - PYTHONUNBUFFERED=1
+`;
+        await fs_extra_1.default.writeFile(path_1.default.join(outputDir, 'docker-compose.yml'), dockerComposeContent, 'utf-8');
+        // Create .dockerignore
+        const dockerignoreContent = `__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.pytest_cache
+.ruff_cache
+.venv
+venv
+.git
+.github
+README.md
+`;
+        await fs_extra_1.default.writeFile(path_1.default.join(outputDir, '.dockerignore'), dockerignoreContent, 'utf-8');
+        // Add CI/CD if requested
+        if (options.cicd === 'github') {
+            await fs_extra_1.default.ensureDir(path_1.default.join(outputDir, '.github', 'workflows'));
+            const workflowContent = `name: Deploy MCP
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install uv
+        run: pip install uv
+
+      - name: Install dependencies
+        run: uv pip install --system -e ".[dev]"
+
+      - name: Run tests
+        run: pytest
+
+      - name: Check code formatting
+        run: |
+          black --check .
+          ruff check .
+
+  docker:
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Build Docker image
+        run: docker build -t mcp-${name}:latest .
+
+      - name: Test Docker image
+        run: docker run --rm mcp-${name}:latest python -c "import fastmcp; print('OK')"
+
+  deploy:
+    needs: [build, docker]
+    runs-on: ubuntu-latest
+    if: github.ref == 'refs/heads/main'
+    steps:
+      - uses: actions/checkout@v4
+      ${options.deployment === 'aws' ? `
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v4
+        with:
+          aws-access-key-id: \${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: \${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: us-east-1
+
+      - name: Login to Amazon ECR
+        id: login-ecr
+        uses: aws-actions/amazon-ecr-login@v2
+
+      - name: Build and push Docker image
+        env:
+          ECR_REGISTRY: \${{ steps.login-ecr.outputs.registry }}
+          ECR_REPOSITORY: mcp-${name}
+          IMAGE_TAG: \${{ github.sha }}
+        run: |
+          docker build -t \$ECR_REGISTRY/\$ECR_REPOSITORY:\$IMAGE_TAG .
+          docker push \$ECR_REGISTRY/\$ECR_REPOSITORY:\$IMAGE_TAG
+          docker tag \$ECR_REGISTRY/\$ECR_REPOSITORY:\$IMAGE_TAG \$ECR_REGISTRY/\$ECR_REPOSITORY:latest
+          docker push \$ECR_REGISTRY/\$ECR_REPOSITORY:latest
+` : ''}${options.deployment === 'gcp' ? `
+      - name: Authenticate to Google Cloud
+        uses: google-github-actions/auth@v2
+        with:
+          credentials_json: \${{ secrets.GCP_CREDENTIALS }}
+
+      - name: Set up Cloud SDK
+        uses: google-github-actions/setup-gcloud@v2
+
+      - name: Build and push Docker image
+        run: |
+          gcloud builds submit --tag gcr.io/\${{ secrets.GCP_PROJECT_ID }}/mcp-${name}:latest
+` : ''}
+`;
+            await fs_extra_1.default.writeFile(path_1.default.join(outputDir, '.github', 'workflows', 'deploy.yml'), workflowContent, 'utf-8');
+        }
+        core_1.logger.succeedSpinner('MCP created successfully!');
+        core_1.logger.section('Next steps', [
+            `1. cd ${outputDir}`,
+            '2. docker-compose up  # Start with Docker',
+            '',
+            'Or for local development:',
+            '2. uv pip install -e .',
+            '3. python server.py',
+            '',
+            'Or use MCP Inspector:',
+            '2. uv pip install -e .',
+            '3. fastmcp dev server.py',
+            '',
+            'Add to Claude Code settings to use this MCP'
+        ]);
+        core_1.logger.success(`✨ MCP "${name}" ready to use!`);
+    }
+    catch (error) {
+        core_1.logger.failSpinner('Failed to create MCP');
+        throw error;
+    }
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,5 @@
+interface LoginOptions {
+    key?: string;
+}
+export declare function loginCommand(options: LoginOptions): Promise<void>;
+export {};

package/dist/commands/login.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginCommand = loginCommand;
+const core_1 = require("@neural-tools/core");
+const inquirer_1 = __importDefault(require("inquirer"));
+async function loginCommand(options) {
+    core_1.logger.header('AI Toolkit License Management');
+    let licenseKey = options.key;
+    if (!licenseKey) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'licenseKey',
+                message: 'Enter your license key:',
+                validate: (input) => {
+                    if (!input || input.trim().length === 0) {
+                        return 'License key is required';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        licenseKey = answers.licenseKey;
+    }
+    if (!licenseKey) {
+        core_1.logger.error('License key is required');
+        return;
+    }
+    core_1.logger.startSpinner('Validating license...');
+    try {
+        // TODO: Validate license key with backend API
+        // For now, parse the key format: tier-email-signature
+        const parts = licenseKey.split('-');
+        if (parts.length < 2) {
+            throw new Error('Invalid license key format');
+        }
+        const tier = parts[0];
+        const email = parts[1];
+        // Validate tier
+        if (!Object.values(core_1.LicenseTier).includes(tier)) {
+            throw new Error('Invalid license tier');
+        }
+        // Save license
+        await core_1.licenseManager.saveLicense({
+            tier,
+            email,
+            key: licenseKey,
+            features: []
+        });
+        core_1.logger.succeedSpinner('License activated successfully!');
+        const license = await core_1.licenseManager.loadLicense();
+        core_1.logger.section('License Details', [
+            `Tier: ${license.tier.toUpperCase()}`,
+            `Email: ${license.email || 'N/A'}`,
+            `Status: Active`
+        ]);
+        // Show available features based on tier
+        const features = getFeaturesByTier(tier);
+        core_1.logger.section('Available Features', features);
+        if (tier === core_1.LicenseTier.FREE) {
+            core_1.logger.newline();
+            core_1.logger.info('Upgrade to Pro for advanced features:');
+            core_1.logger.info('https://ai-toolkit.dev/pricing');
+        }
+        core_1.logger.success('✨ Ready to build!');
+    }
+    catch (error) {
+        core_1.logger.failSpinner('License validation failed');
+        core_1.logger.error(error.message || 'Invalid license key');
+        core_1.logger.newline();
+        core_1.logger.info('Get a license at: https://ai-toolkit.dev/pricing');
+        core_1.logger.info('Or continue with free tier features');
+    }
+}
+function getFeaturesByTier(tier) {
+    const freeTier = [
+        '✓ MCP generation',
+        '✓ Claude commands',
+        '✓ Basic templates',
+        '✓ Local development'
+    ];
+    const proTier = [
+        ...freeTier,
+        '✓ Vector database integration',
+        '✓ Semantic caching',
+        '✓ Fine-tuning workflows',
+        '✓ Cloud deployment (AWS/GCP)',
+        '✓ Premium templates',
+        '✓ GitHub automation'
+    ];
+    const enterpriseTier = [
+        ...proTier,
+        '✓ White-label support',
+        '✓ Custom integrations',
+        '✓ Priority support',
+        '✓ SLA guarantee',
+        '✓ Team collaboration features'
+    ];
+    switch (tier) {
+        case core_1.LicenseTier.FREE:
+            return freeTier;
+        case core_1.LicenseTier.PRO:
+            return proTier;
+        case core_1.LicenseTier.ENTERPRISE:
+            return enterpriseTier;
+        default:
+            return freeTier;
+    }
+}

package/dist/commands/status.d.ts

@@ -0,0 +1 @@
+export declare function statusCommand(): Promise<void>;

package/dist/commands/status.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const core_1 = require("@neural-tools/core");
+async function statusCommand() {
+    core_1.logger.header('AI Toolkit Status');
+    try {
+        const license = await core_1.licenseManager.loadLicense();
+        core_1.logger.section('License Information', [
+            `Tier: ${license.tier.toUpperCase()}`,
+            `Email: ${license.email || 'N/A'}`,
+            `Status: ${license.expiresAt ? checkExpiration(license.expiresAt) : 'Active'}`
+        ]);
+        // Check available features
+        const features = [
+            { name: 'MCP Generation', key: 'mcp-generation' },
+            { name: 'Claude Commands', key: 'claude-commands' },
+            { name: 'Vector Database', key: 'vector-db' },
+            { name: 'Semantic Cache', key: 'semantic-cache' },
+            { name: 'Fine-tuning', key: 'fine-tuning' },
+            { name: 'Cloud Deployment', key: 'cloud-deployment' },
+            { name: 'GitHub Automation', key: 'github-automation' }
+        ];
+        const featureStatus = await Promise.all(features.map(async (feature) => {
+            const available = await core_1.licenseManager.checkFeature(feature.key);
+            return `${available ? '✓' : '✗'} ${feature.name}`;
+        }));
+        core_1.logger.section('Feature Availability', featureStatus);
+        if (license.tier === core_1.LicenseTier.FREE) {
+            core_1.logger.newline();
+            core_1.logger.info('Unlock more features with Pro or Enterprise:');
+            core_1.logger.info('https://ai-toolkit.dev/pricing');
+        }
+        core_1.logger.newline();
+        core_1.logger.section('Quick Start', [
+            'Generate an MCP server:',
+            '  ai-toolkit generate mcp github',
+            '',
+            'Generate a Claude command:',
+            '  ai-toolkit generate command search-kb',
+            '',
+            'View all commands:',
+            '  ai-toolkit --help'
+        ]);
+    }
+    catch (error) {
+        core_1.logger.error('Failed to load license information');
+        core_1.logger.newline();
+        core_1.logger.info('Run "ai-toolkit login" to activate your license');
+        core_1.logger.info('Or continue with free tier features');
+    }
+}
+function checkExpiration(expiresAt) {
+    const expirationDate = new Date(expiresAt);
+    const now = new Date();
+    if (expirationDate < now) {
+        return 'Expired';
+    }
+    const daysUntilExpiration = Math.ceil((expirationDate.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+    if (daysUntilExpiration <= 30) {
+        return `Active (expires in ${daysUntilExpiration} days)`;
+    }
+    return 'Active';
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { generateMCP } from './commands/generate-mcp';
+export { generateCommand } from './commands/generate-command';
+export { generateAgent } from './commands/generate-agent';
+export { deployMCP } from './commands/deploy';
+export { loginCommand } from './commands/login';
+export { statusCommand } from './commands/status';

package/dist/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = exports.loginCommand = exports.deployMCP = exports.generateAgent = exports.generateCommand = exports.generateMCP = void 0;
+var generate_mcp_1 = require("./commands/generate-mcp");
+Object.defineProperty(exports, "generateMCP", { enumerable: true, get: function () { return generate_mcp_1.generateMCP; } });
+var generate_command_1 = require("./commands/generate-command");
+Object.defineProperty(exports, "generateCommand", { enumerable: true, get: function () { return generate_command_1.generateCommand; } });
+var generate_agent_1 = require("./commands/generate-agent");
+Object.defineProperty(exports, "generateAgent", { enumerable: true, get: function () { return generate_agent_1.generateAgent; } });
+var deploy_1 = require("./commands/deploy");
+Object.defineProperty(exports, "deployMCP", { enumerable: true, get: function () { return deploy_1.deployMCP; } });
+var login_1 = require("./commands/login");
+Object.defineProperty(exports, "loginCommand", { enumerable: true, get: function () { return login_1.loginCommand; } });
+var status_1 = require("./commands/status");
+Object.defineProperty(exports, "statusCommand", { enumerable: true, get: function () { return status_1.statusCommand; } });

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@neural-tools/cli",
+  "version": "0.1.0",
+  "description": "CLI for Neural Tools - Generate MCPs, Claude commands, and AI workflows",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "neural-tools": "./dist/cli.js"
+  },
+  "license": "SEE LICENSE IN ../../LICENSE.md",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/ai-toolkit.git",
+    "directory": "packages/cli"
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "inquirer": "^9.2.12",
+    "execa": "^8.0.1",
+    "fs-extra": "^11.2.0",
+    "globby": "^14.0.0",
+    "picocolors": "^1.0.0",
+    "@neural-tools/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^20.11.5",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc && chmod +x dist/cli.js",
+    "dev": "tsc --watch",
+    "clean": "rm -rf dist",
+    "test": "echo 'Tests coming soon'"
+  }
+}