@ggakila/agentx-framework 0.1.0

package/dist/cli/InteractiveSetup.js

@@ -0,0 +1,2225 @@
+"use strict";
+/**
+ * Interactive Setup for AgentX
+ * Provides a Next.js-like interactive CLI experience for project setup
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectGenerator = exports.SetupWizard = exports.InteractivePrompt = exports.AGENT_PERSONALITIES = exports.SECURITY_OPTIONS = exports.DEPLOYMENT_OPTIONS = exports.FEATURES = exports.INTEGRATIONS = exports.LLM_PROVIDERS = void 0;
+const readline = __importStar(require("readline"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Available LLM providers
+exports.LLM_PROVIDERS = [
+    { value: 'openai', label: 'OpenAI', description: 'GPT-4, GPT-3.5 (requires OPENAI_API_KEY)' },
+    { value: 'anthropic', label: 'Anthropic', description: 'Claude 3 (requires ANTHROPIC_API_KEY)' },
+    { value: 'local', label: 'Local Model', description: 'Ollama, LM Studio (no API key needed)' },
+];
+// Available integrations
+exports.INTEGRATIONS = [
+    { value: 'http', label: 'HTTP/REST', description: 'Make HTTP requests to APIs', selected: true },
+    { value: 'webhook', label: 'Webhooks', description: 'Receive and send webhooks' },
+    { value: 'scheduler', label: 'Scheduler', description: 'Cron jobs and scheduled tasks' },
+    { value: 'email', label: 'Email', description: 'Send emails via SMTP' },
+    { value: 'slack', label: 'Slack', description: 'Slack messaging integration' },
+    { value: 'whatsapp', label: 'WhatsApp', description: 'WhatsApp Business API' },
+    { value: 'telegram', label: 'Telegram', description: 'Telegram Bot API' },
+    { value: 'google-docs', label: 'Google Docs', description: 'Google Docs API' },
+    { value: 'google-sheets', label: 'Google Sheets', description: 'Google Sheets API' },
+    { value: 'google-drive', label: 'Google Drive', description: 'Google Drive API' },
+    { value: 'sql', label: 'SQL Database', description: 'PostgreSQL, MySQL, SQLite' },
+    { value: 'mongodb', label: 'MongoDB', description: 'MongoDB connector' },
+    { value: 'redis', label: 'Redis', description: 'Redis cache/store' },
+    { value: 's3', label: 'Amazon S3', description: 'S3 file storage' },
+    { value: 'filesystem', label: 'File System', description: 'Local file operations' },
+];
+// Available features
+exports.FEATURES = [
+    { value: 'workflows', label: 'Workflows', description: 'DAG-based workflow execution', selected: true },
+    { value: 'agents', label: 'AI Agents', description: 'Autonomous AI agents with tool use', selected: true },
+    { value: 'credentials', label: 'Credential Manager', description: 'Encrypted credential storage' },
+    { value: 'security', label: 'Security', description: 'RBAC, rate limiting, audit logs' },
+    { value: 'plugins', label: 'Plugin System', description: 'Extensible plugin architecture' },
+    { value: 'payments', label: 'Payments', description: 'Stripe, PayPal, M-Pesa integration' },
+];
+// Deployment options
+exports.DEPLOYMENT_OPTIONS = [
+    { value: 'docker', label: 'Docker', description: 'Containerized deployment with Dockerfile' },
+    { value: 'docker-compose', label: 'Docker Compose', description: 'Multi-service setup with databases' },
+    { value: 'kubernetes', label: 'Kubernetes', description: 'K8s manifests for production deployment' },
+    { value: 'railway', label: 'Railway', description: 'One-click Railway deployment' },
+    { value: 'vercel', label: 'Vercel', description: 'Serverless deployment on Vercel' },
+    { value: 'aws-lambda', label: 'AWS Lambda', description: 'Serverless functions on AWS' },
+    { value: 'systemd', label: 'Systemd Service', description: 'Linux service configuration' },
+];
+// Security enhancements
+exports.SECURITY_OPTIONS = [
+    { value: 'https-only', label: 'HTTPS Only', description: 'Force HTTPS and security headers', selected: true },
+    { value: 'api-keys', label: 'API Key Authentication', description: 'Secure API access with keys' },
+    { value: 'jwt', label: 'JWT Authentication', description: 'JSON Web Token authentication' },
+    { value: 'rate-limiting', label: 'Rate Limiting', description: 'Prevent API abuse and DoS attacks' },
+    { value: 'input-validation', label: 'Input Validation', description: 'Strict input sanitization' },
+    { value: 'audit-logging', label: 'Audit Logging', description: 'Security event logging' },
+    { value: 'secrets-manager', label: 'Secrets Manager', description: 'External secrets management' },
+];
+// Agent personality presets
+exports.AGENT_PERSONALITIES = [
+    { value: 'helpful', label: 'Helpful Assistant', description: 'Friendly and supportive' },
+    { value: 'professional', label: 'Professional', description: 'Formal and business-focused' },
+    { value: 'concise', label: 'Concise', description: 'Brief and to-the-point' },
+    { value: 'creative', label: 'Creative', description: 'Imaginative and exploratory' },
+    { value: 'custom', label: 'Custom', description: 'Define your own personality' },
+];
+/**
+ * Interactive prompt utilities
+ */
+class InteractivePrompt {
+    rl;
+    constructor() {
+        this.rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+    }
+    async text(question, defaultValue) {
+        const prompt = defaultValue ? `${question} (${defaultValue}): ` : `${question}: `;
+        return new Promise((resolve) => {
+            this.rl.question(prompt, (answer) => {
+                resolve(answer.trim() || defaultValue || '');
+            });
+        });
+    }
+    async confirm(question, defaultValue = true) {
+        const hint = defaultValue ? '(Y/n)' : '(y/N)';
+        return new Promise((resolve) => {
+            this.rl.question(`${question} ${hint}: `, (answer) => {
+                const normalized = answer.trim().toLowerCase();
+                if (normalized === '')
+                    resolve(defaultValue);
+                else
+                    resolve(normalized === 'y' || normalized === 'yes');
+            });
+        });
+    }
+    async select(question, choices) {
+        console.log(`\n${question}`);
+        choices.forEach((choice, index) => {
+            const desc = choice.description ? ` - ${choice.description}` : '';
+            console.log(`  ${index + 1}. ${choice.label}${desc}`);
+        });
+        return new Promise((resolve) => {
+            const ask = () => {
+                this.rl.question('\nEnter number: ', (answer) => {
+                    const index = parseInt(answer.trim(), 10) - 1;
+                    if (index >= 0 && index < choices.length) {
+                        resolve(choices[index].value);
+                    }
+                    else {
+                        console.log('Invalid selection. Please try again.');
+                        ask();
+                    }
+                });
+            };
+            ask();
+        });
+    }
+    async multiSelect(question, choices) {
+        console.log(`\n${question}`);
+        console.log('(Enter numbers separated by commas, or "all" for all, "none" to skip)\n');
+        choices.forEach((choice, index) => {
+            const selected = choice.selected ? '✓' : ' ';
+            const desc = choice.description ? ` - ${choice.description}` : '';
+            console.log(`  [${selected}] ${index + 1}. ${choice.label}${desc}`);
+        });
+        return new Promise((resolve) => {
+            const ask = () => {
+                this.rl.question('\nEnter numbers (e.g., 1,2,3) or "all"/"none": ', (answer) => {
+                    const normalized = answer.trim().toLowerCase();
+                    if (normalized === 'all') {
+                        resolve(choices.map(c => c.value));
+                        return;
+                    }
+                    if (normalized === '' || normalized === 'none') {
+                        resolve(choices.filter(c => c.selected).map(c => c.value));
+                        return;
+                    }
+                    const indices = normalized.split(',').map(s => parseInt(s.trim(), 10) - 1);
+                    const valid = indices.every(i => i >= 0 && i < choices.length);
+                    if (valid) {
+                        resolve(indices.map(i => choices[i].value));
+                    }
+                    else {
+                        console.log('Invalid selection. Please try again.');
+                        ask();
+                    }
+                });
+            };
+            ask();
+        });
+    }
+    close() {
+        this.rl.close();
+    }
+}
+exports.InteractivePrompt = InteractivePrompt;
+/**
+ * Setup Wizard - orchestrates the interactive project setup
+ */
+class SetupWizard {
+    prompt;
+    constructor() {
+        this.prompt = new InteractivePrompt();
+    }
+    /**
+     * Run the interactive setup wizard
+     */
+    async run(projectName) {
+        this.printBanner();
+        // Project name
+        const name = projectName || await this.prompt.text('What is your project named?', 'my-agentx-app');
+        // LLM Providers
+        console.log('\n📦 LLM Providers');
+        const llmProviders = await this.prompt.multiSelect('Which LLM providers would you like to use?', exports.LLM_PROVIDERS);
+        // Integrations
+        console.log('\n🔌 Integrations');
+        const integrations = await this.prompt.multiSelect('Which integrations would you like to include?', exports.INTEGRATIONS);
+        // Features
+        console.log('\n⚡ Features');
+        const features = await this.prompt.multiSelect('Which features would you like to enable?', exports.FEATURES);
+        // Agent personality
+        console.log('\n🤖 Agent Configuration');
+        let agentPersonality = await this.prompt.select('Choose a default agent personality:', exports.AGENT_PERSONALITIES);
+        if (agentPersonality === 'custom') {
+            agentPersonality = await this.prompt.text('Describe your agent personality', 'You are a helpful AI assistant.');
+        }
+        // TypeScript
+        const typescript = await this.prompt.confirm('Use TypeScript?', true);
+        // Deployment options
+        console.log('\n🚀 Deployment');
+        const deployment = await this.prompt.multiSelect('How would you like to deploy your application?', exports.DEPLOYMENT_OPTIONS);
+        // Security options
+        console.log('\n🔒 Security');
+        const security = await this.prompt.multiSelect('Which security features would you like to enable?', exports.SECURITY_OPTIONS);
+        // Git
+        const git = await this.prompt.confirm('Initialize a git repository?', true);
+        this.prompt.close();
+        return {
+            projectName: name,
+            llmProviders,
+            integrations,
+            features,
+            agentPersonality,
+            typescript,
+            git,
+            deployment,
+            security,
+        };
+    }
+    printBanner() {
+        console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                                                           ║
+║     █████╗  ██████╗ ███████╗███╗   ██╗████████╗██╗  ██╗   ║
+║    ██╔══██╗██╔════╝ ██╔════╝████╗  ██║╚══██╔══╝╚██╗██╔╝   ║
+║    ███████║██║  ███╗█████╗  ██╔██╗ ██║   ██║    ╚███╔╝    ║
+║    ██╔══██║██║   ██║██╔══╝  ██║╚██╗██║   ██║    ██╔██╗    ║
+║    ██║  ██║╚██████╔╝███████╗██║ ╚████║   ██║   ██╔╝ ██╗   ║
+║    ╚═╝  ╚═╝ ╚═════╝ ╚══════╝╚═╝  ╚═══╝   ╚═╝   ╚═╝  ╚═╝   ║
+║                                                           ║
+║           Production-Grade AI Agent Framework             ║
+║                                                           ║
+╚═══════════════════════════════════════════════════════════╝
+`);
+    }
+}
+exports.SetupWizard = SetupWizard;
+/**
+ * Project Generator - creates project files based on setup options
+ */
+class ProjectGenerator {
+    /**
+     * Generate project from setup options
+     */
+    async generate(options, targetDir) {
+        const projectDir = path.join(targetDir, options.projectName);
+        // Create directories
+        this.createDirectories(projectDir, options);
+        // Generate files
+        await this.generatePackageJson(projectDir, options);
+        await this.generateTsConfig(projectDir, options);
+        await this.generateConfig(projectDir, options);
+        await this.generateEnvFile(projectDir, options);
+        await this.generateEntryPoint(projectDir, options);
+        await this.generateExampleAgent(projectDir, options);
+        // Generate payment examples if payments feature is selected
+        if (options.features.includes('payments')) {
+            await this.generatePaymentExamples(projectDir, options);
+        }
+        // Generate deployment files
+        await this.generateDeploymentFiles(projectDir, options);
+        // Generate security files
+        await this.generateSecurityFiles(projectDir, options);
+        if (options.git) {
+            await this.generateGitIgnore(projectDir);
+        }
+        console.log(`\n✅ Project created at ${projectDir}`);
+        this.printNextSteps(options);
+    }
+    createDirectories(projectDir, options) {
+        const dirs = [
+            projectDir,
+            path.join(projectDir, 'src'),
+            path.join(projectDir, 'src', 'agents'),
+        ];
+        if (options.features.includes('workflows')) {
+            dirs.push(path.join(projectDir, 'src', 'workflows'));
+        }
+        if (options.integrations.length > 0) {
+            dirs.push(path.join(projectDir, 'src', 'tools'));
+        }
+        for (const dir of dirs) {
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+    }
+    async generatePackageJson(projectDir, options) {
+        const dependencies = {
+            agentx: '^0.1.0',
+        };
+        const devDependencies = {
+            jest: '^29.0.0',
+        };
+        // Add TypeScript dependencies
+        if (options.typescript) {
+            devDependencies['@types/node'] = '^20.0.0';
+            devDependencies['typescript'] = '^5.0.0';
+            devDependencies['ts-node'] = '^10.0.0';
+            devDependencies['@types/jest'] = '^29.0.0';
+        }
+        // Add security dependencies
+        if (options.security.includes('input-validation')) {
+            dependencies['joi'] = '^17.11.0';
+            if (options.typescript) {
+                devDependencies['@types/joi'] = '^17.2.0';
+            }
+        }
+        if (options.security.includes('jwt')) {
+            dependencies['jsonwebtoken'] = '^9.0.2';
+            if (options.typescript) {
+                devDependencies['@types/jsonwebtoken'] = '^9.0.5';
+            }
+        }
+        if (options.security.includes('rate-limiting')) {
+            dependencies['express-rate-limit'] = '^7.1.5';
+        }
+        // Add deployment dependencies
+        if (options.deployment.includes('aws-lambda')) {
+            dependencies['aws-lambda'] = '^1.0.7';
+            if (options.typescript) {
+                devDependencies['@types/aws-lambda'] = '^8.10.130';
+            }
+        }
+        // Add integration-specific dependencies
+        if (options.integrations.includes('email')) {
+            dependencies['nodemailer'] = '^6.9.7';
+            if (options.typescript) {
+                devDependencies['@types/nodemailer'] = '^6.4.14';
+            }
+        }
+        const scripts = {
+            test: 'jest',
+        };
+        if (options.typescript) {
+            scripts.build = 'tsc';
+            scripts.start = 'node dist/index.js';
+            scripts.dev = 'ts-node src/index.ts';
+            scripts['type-check'] = 'tsc --noEmit';
+        }
+        else {
+            scripts.start = 'node src/index.js';
+            scripts.dev = 'nodemon src/index.js';
+            devDependencies.nodemon = '^3.0.2';
+        }
+        // Add deployment scripts
+        if (options.deployment.includes('docker')) {
+            scripts['docker:build'] = `docker build -t ${options.projectName} .`;
+            scripts['docker:run'] = `docker run -p 3000:3000 ${options.projectName}`;
+        }
+        if (options.deployment.includes('docker-compose')) {
+            scripts['compose:up'] = 'docker-compose up -d';
+            scripts['compose:down'] = 'docker-compose down';
+            scripts['compose:logs'] = 'docker-compose logs -f';
+        }
+        if (options.deployment.includes('kubernetes')) {
+            scripts['k8s:deploy'] = 'kubectl apply -f k8s/';
+            scripts['k8s:delete'] = 'kubectl delete -f k8s/';
+        }
+        // Add security scripts
+        if (options.security.length > 0) {
+            scripts['security:audit'] = 'npm audit';
+            scripts['security:fix'] = 'npm audit fix';
+        }
+        const pkg = {
+            name: options.projectName,
+            version: '1.0.0',
+            description: 'AgentX AI Agent Project',
+            main: options.typescript ? 'dist/index.js' : 'src/index.js',
+            scripts,
+            dependencies,
+            devDependencies,
+            engines: {
+                node: '>=18.0.0',
+            },
+            keywords: [
+                'agentx',
+                'ai',
+                'agent',
+                'automation',
+                ...options.integrations,
+                ...options.features,
+            ],
+        };
+        fs.writeFileSync(path.join(projectDir, 'package.json'), JSON.stringify(pkg, null, 2));
+    }
+    async generateTsConfig(projectDir, options) {
+        if (!options.typescript)
+            return;
+        const tsconfig = {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'commonjs',
+                lib: ['ES2020'],
+                outDir: './dist',
+                rootDir: './src',
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                declaration: true,
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules', 'dist'],
+        };
+        fs.writeFileSync(path.join(projectDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2));
+    }
+    async generateConfig(projectDir, options) {
+        const ext = options.typescript ? 'ts' : 'js';
+        const exportKeyword = options.typescript ? 'export default' : 'module.exports =';
+        const llmConfig = this.generateLLMConfig(options);
+        const integrationsConfig = this.generateIntegrationsConfig(options);
+        const content = `/**
+ * AgentX Configuration
+ * Generated by create-agentx
+ */
+${exportKeyword} {
+  runtime: {
+    name: '${options.projectName}',
+    version: '1.0.0',
+  },
+  llm: {
+    defaultProvider: '${options.llmProviders[0] || 'openai'}',
+    providers: {
+${llmConfig}
+    },
+  },
+  integrations: {
+${integrationsConfig}
+  },
+  features: {
+    workflows: ${options.features.includes('workflows')},
+    agents: ${options.features.includes('agents')},
+    credentials: ${options.features.includes('credentials')},
+    security: ${options.features.includes('security')},
+    plugins: ${options.features.includes('plugins')},
+    payments: ${options.features.includes('payments')},
+  },
+  agent: {
+    defaultPersonality: '${this.escapeString(options.agentPersonality)}',
+  },
+};
+`;
+        fs.writeFileSync(path.join(projectDir, 'src', `config.${ext}`), content);
+    }
+    generateLLMConfig(options) {
+        const configs = [];
+        if (options.llmProviders.includes('openai')) {
+            configs.push(`      openai: {
+        apiKey: process.env.OPENAI_API_KEY,
+        model: 'gpt-4',
+      }`);
+        }
+        if (options.llmProviders.includes('anthropic')) {
+            configs.push(`      anthropic: {
+        apiKey: process.env.ANTHROPIC_API_KEY,
+        model: 'claude-3-opus-20240229',
+      }`);
+        }
+        if (options.llmProviders.includes('local')) {
+            configs.push(`      local: {
+        baseUrl: process.env.LOCAL_LLM_URL || 'http://localhost:11434',
+        model: 'llama2',
+      }`);
+        }
+        return configs.join(',\n');
+    }
+    generateIntegrationsConfig(options) {
+        const configs = [];
+        for (const integration of options.integrations) {
+            configs.push(`    '${integration}': { enabled: true }`);
+        }
+        return configs.join(',\n');
+    }
+    async generateEnvFile(projectDir, options) {
+        const lines = ['# AgentX Environment Variables', '# Generated based on your selections', ''];
+        // Core application settings
+        lines.push('# Application Configuration');
+        lines.push(`NODE_ENV=development`);
+        lines.push(`PORT=3000`);
+        lines.push('');
+        // LLM Provider configurations (only selected ones)
+        if (options.llmProviders.includes('openai')) {
+            lines.push('# OpenAI Configuration');
+            lines.push('OPENAI_API_KEY=your-openai-api-key-here');
+            lines.push('# Optional: OPENAI_ORG_ID=your-org-id');
+            lines.push('');
+        }
+        if (options.llmProviders.includes('anthropic')) {
+            lines.push('# Anthropic Configuration');
+            lines.push('ANTHROPIC_API_KEY=your-anthropic-api-key-here');
+            lines.push('');
+        }
+        if (options.llmProviders.includes('local')) {
+            lines.push('# Local LLM Configuration');
+            lines.push('LOCAL_LLM_URL=http://localhost:11434');
+            lines.push('# For Ollama: LOCAL_LLM_MODEL=llama2');
+            lines.push('');
+        }
+        // Integration-specific env vars (only selected ones)
+        if (options.integrations.includes('email')) {
+            lines.push('# Email Configuration (SMTP)');
+            lines.push('SMTP_HOST=smtp.gmail.com');
+            lines.push('SMTP_PORT=587');
+            lines.push('SMTP_SECURE=false');
+            lines.push('SMTP_USER=your-email@gmail.com');
+            lines.push('SMTP_PASS=your-app-password');
+            lines.push('');
+        }
+        if (options.integrations.includes('slack')) {
+            lines.push('# Slack Configuration');
+            lines.push('SLACK_BOT_TOKEN=xoxb-your-bot-token');
+            lines.push('SLACK_SIGNING_SECRET=your-signing-secret');
+            lines.push('');
+        }
+        if (options.integrations.includes('whatsapp')) {
+            lines.push('# WhatsApp Business API');
+            lines.push('WHATSAPP_TOKEN=your-whatsapp-token');
+            lines.push('WHATSAPP_PHONE_ID=your-phone-number-id');
+            lines.push('WHATSAPP_VERIFY_TOKEN=your-verify-token');
+            lines.push('');
+        }
+        if (options.integrations.includes('telegram')) {
+            lines.push('# Telegram Bot Configuration');
+            lines.push('TELEGRAM_BOT_TOKEN=your-bot-token');
+            lines.push('');
+        }
+        if (options.integrations.includes('google-docs') ||
+            options.integrations.includes('google-sheets') ||
+            options.integrations.includes('google-drive')) {
+            lines.push('# Google Workspace Configuration');
+            lines.push('GOOGLE_CLIENT_ID=your-client-id');
+            lines.push('GOOGLE_CLIENT_SECRET=your-client-secret');
+            lines.push('GOOGLE_REDIRECT_URI=http://localhost:3000/auth/google/callback');
+            lines.push('# Service Account (alternative to OAuth)');
+            lines.push('# GOOGLE_SERVICE_ACCOUNT_KEY=path/to/service-account.json');
+            lines.push('');
+        }
+        if (options.integrations.includes('sql')) {
+            lines.push('# Database Configuration');
+            lines.push('DATABASE_URL=postgresql://user:password@localhost:5432/agentx_db');
+            lines.push('# Alternative formats:');
+            lines.push('# DATABASE_URL=mysql://user:password@localhost:3306/agentx_db');
+            lines.push('# DATABASE_URL=sqlite:./data/agentx.db');
+            lines.push('');
+        }
+        if (options.integrations.includes('mongodb')) {
+            lines.push('# MongoDB Configuration');
+            lines.push('MONGODB_URI=mongodb://localhost:27017/agentx');
+            lines.push('# For MongoDB Atlas:');
+            lines.push('# MONGODB_URI=mongodb+srv://user:password@cluster.mongodb.net/agentx');
+            lines.push('');
+        }
+        if (options.integrations.includes('redis')) {
+            lines.push('# Redis Configuration');
+            lines.push('REDIS_URL=redis://localhost:6379');
+            lines.push('# For Redis Cloud:');
+            lines.push('# REDIS_URL=redis://user:password@host:port');
+            lines.push('');
+        }
+        if (options.integrations.includes('s3')) {
+            lines.push('# AWS S3 Configuration');
+            lines.push('AWS_ACCESS_KEY_ID=your-access-key-id');
+            lines.push('AWS_SECRET_ACCESS_KEY=your-secret-access-key');
+            lines.push('AWS_REGION=us-east-1');
+            lines.push('S3_BUCKET_NAME=your-bucket-name');
+            lines.push('');
+        }
+        // Payment integrations (only if selected)
+        if (options.features.includes('payments')) {
+            lines.push('# Payment Configuration');
+            lines.push('# Stripe');
+            lines.push('STRIPE_SECRET_KEY=sk_test_your-stripe-secret-key');
+            lines.push('STRIPE_PUBLISHABLE_KEY=pk_test_your-stripe-publishable-key');
+            lines.push('STRIPE_WEBHOOK_SECRET=whsec_your-webhook-secret');
+            lines.push('');
+            lines.push('# PayPal Configuration');
+            lines.push('PAYPAL_CLIENT_ID=your-paypal-client-id');
+            lines.push('PAYPAL_CLIENT_SECRET=your-paypal-client-secret');
+            lines.push('PAYPAL_MODE=sandbox # or live');
+            lines.push('');
+            lines.push('# M-Pesa Configuration (Safaricom)');
+            lines.push('MPESA_CONSUMER_KEY=your-mpesa-consumer-key');
+            lines.push('MPESA_CONSUMER_SECRET=your-mpesa-consumer-secret');
+            lines.push('MPESA_SHORTCODE=174379 # Your business shortcode');
+            lines.push('MPESA_PASSKEY=your-mpesa-passkey');
+            lines.push('MPESA_ENVIRONMENT=sandbox # or production');
+            lines.push('MPESA_CALLBACK_URL=https://yourdomain.com/api/mpesa/callback');
+            lines.push('MPESA_WEBHOOK_URL=https://yourdomain.com/api/mpesa/webhook');
+            lines.push('');
+        }
+        // Security configurations (only if selected)
+        if (options.security.includes('jwt')) {
+            lines.push('# JWT Configuration');
+            lines.push('JWT_SECRET=your-super-secret-jwt-key-change-this-in-production');
+            lines.push('JWT_EXPIRES_IN=24h');
+            lines.push('');
+        }
+        if (options.security.includes('api-keys')) {
+            lines.push('# API Key Configuration');
+            lines.push('API_KEY_HEADER=X-API-Key');
+            lines.push('MASTER_API_KEY=your-master-api-key-change-this');
+            lines.push('');
+        }
+        if (options.security.includes('rate-limiting')) {
+            lines.push('# Rate Limiting Configuration');
+            lines.push('RATE_LIMIT_WINDOW_MS=900000 # 15 minutes');
+            lines.push('RATE_LIMIT_MAX_REQUESTS=100');
+            lines.push('');
+        }
+        if (options.security.includes('secrets-manager')) {
+            lines.push('# External Secrets Manager');
+            lines.push('# AWS Secrets Manager');
+            lines.push('# AWS_SECRETS_REGION=us-east-1');
+            lines.push('# HashiCorp Vault');
+            lines.push('# VAULT_ADDR=https://vault.example.com');
+            lines.push('# VAULT_TOKEN=your-vault-token');
+            lines.push('');
+        }
+        // Credential manager (only if selected)
+        if (options.features.includes('credentials')) {
+            lines.push('# Credential Manager');
+            lines.push('CREDENTIAL_ENCRYPTION_KEY=your-32-character-encryption-key-here');
+            lines.push('');
+        }
+        // Deployment-specific variables
+        if (options.deployment.includes('docker') || options.deployment.includes('docker-compose')) {
+            lines.push('# Docker Configuration');
+            lines.push('DOCKER_REGISTRY=your-registry.com');
+            lines.push('IMAGE_TAG=latest');
+            lines.push('');
+        }
+        if (options.deployment.includes('kubernetes')) {
+            lines.push('# Kubernetes Configuration');
+            lines.push('K8S_NAMESPACE=agentx');
+            lines.push('K8S_SERVICE_ACCOUNT=agentx-service');
+            lines.push('');
+        }
+        // Monitoring and logging (recommended for production)
+        if (options.security.includes('audit-logging') || options.deployment.length > 0) {
+            lines.push('# Monitoring & Logging');
+            lines.push('LOG_LEVEL=info # debug, info, warn, error');
+            lines.push('# SENTRY_DSN=your-sentry-dsn-for-error-tracking');
+            lines.push('# DATADOG_API_KEY=your-datadog-api-key');
+            lines.push('');
+        }
+        fs.writeFileSync(path.join(projectDir, '.env.example'), lines.join('\n'));
+        // Create actual .env with placeholder values
+        const envContent = lines
+            .map(line => {
+            if (line.includes('=') && !line.startsWith('#')) {
+                // Keep the structure but make values obviously placeholder
+                return line.replace(/=.*/, '=CHANGE_ME');
+            }
+            return line;
+        })
+            .join('\n');
+        fs.writeFileSync(path.join(projectDir, '.env'), envContent);
+    }
+    async generateEntryPoint(projectDir, options) {
+        const ext = options.typescript ? 'ts' : 'js';
+        const importStyle = options.typescript
+            ? "import { AgentXRuntime } from 'agentx';\nimport config from './config';"
+            : "const { AgentXRuntime } = require('agentx');\nconst config = require('./config');";
+        const content = `/**
+ * AgentX Application Entry Point
+ * Generated by create-agentx
+ */
+${importStyle}
+
+async function main() {
+  console.log('🚀 Starting ${options.projectName}...');
+  
+  const runtime = new AgentXRuntime(config);
+  await runtime.start();
+  
+  console.log('✅ AgentX runtime started successfully');
+  console.log('📦 Loaded providers:', ${options.typescript ? 'config.llm.providers' : 'Object.keys(config.llm.providers)'});
+  
+  // Graceful shutdown
+  process.on('SIGINT', async () => {
+    console.log('\\n🛑 Shutting down...');
+    await runtime.stop();
+    process.exit(0);
+  });
+}
+
+main().catch((error) => {
+  console.error('❌ Failed to start:', error);
+  process.exit(1);
+});
+`;
+        fs.writeFileSync(path.join(projectDir, 'src', `index.${ext}`), content);
+    }
+    async generateExampleAgent(projectDir, options) {
+        if (!options.features.includes('agents'))
+            return;
+        const ext = options.typescript ? 'ts' : 'js';
+        const exportStyle = options.typescript ? 'export const' : 'module.exports.myAgent =';
+        const typeAnnotation = options.typescript ? ': AgentConfig' : '';
+        const importLine = options.typescript
+            ? "import { AgentConfig } from 'agentx';\n\n"
+            : '';
+        const personality = this.getPersonalityPrompt(options.agentPersonality);
+        const content = `/**
+ * Example AI Agent
+ * Generated by create-agentx
+ */
+${importLine}${exportStyle} myAgent${typeAnnotation} = {
+  name: 'my-agent',
+  description: 'Your custom AI agent',
+  llmProvider: '${options.llmProviders[0] || 'openai'}',
+  model: '${this.getDefaultModel(options.llmProviders[0])}',
+  systemPrompt: \`${personality}\`,
+  allowedTools: [${options.integrations.map(i => `'${i}'`).join(', ')}],
+  maxIterations: 10,
+  temperature: 0.7,
+};
+`;
+        fs.writeFileSync(path.join(projectDir, 'src', 'agents', `myAgent.${ext}`), content);
+    }
+    async generateGitIgnore(projectDir) {
+        const content = `# Dependencies
+node_modules/
+
+# Build output
+dist/
+
+# Environment
+.env
+.env.local
+.env.production
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+npm-debug.log*
+logs/
+
+# Test coverage
+coverage/
+
+# Runtime data
+pids/
+*.pid
+*.seed
+*.pid.lock
+
+# Docker
+.dockerignore
+
+# Secrets
+secrets/
+*.pem
+*.key
+service-account.json
+`;
+        fs.writeFileSync(path.join(projectDir, '.gitignore'), content);
+    }
+    /**
+     * Generate deployment files based on selected options
+     */
+    async generateDeploymentFiles(projectDir, options) {
+        if (options.deployment.includes('docker')) {
+            await this.generateDockerfile(projectDir, options);
+            await this.generateDockerIgnore(projectDir);
+        }
+        if (options.deployment.includes('docker-compose')) {
+            await this.generateDockerCompose(projectDir, options);
+        }
+        if (options.deployment.includes('kubernetes')) {
+            await this.generateKubernetesManifests(projectDir, options);
+        }
+        if (options.deployment.includes('railway')) {
+            await this.generateRailwayConfig(projectDir, options);
+        }
+        if (options.deployment.includes('vercel')) {
+            await this.generateVercelConfig(projectDir, options);
+        }
+        if (options.deployment.includes('aws-lambda')) {
+            await this.generateLambdaConfig(projectDir, options);
+        }
+        if (options.deployment.includes('systemd')) {
+            await this.generateSystemdService(projectDir, options);
+        }
+    }
+    async generateDockerfile(projectDir, options) {
+        const content = `# Multi-stage Docker build for ${options.projectName}
+FROM node:18-alpine AS builder
+
+WORKDIR /app
+
+# Copy package files
+COPY package*.json ./
+${options.typescript ? 'COPY tsconfig.json ./' : ''}
+
+# Install dependencies
+RUN npm ci --only=production && npm cache clean --force
+
+# Copy source code
+COPY src/ ./src/
+
+# Build application
+${options.typescript ? 'RUN npm run build' : ''}
+
+# Production stage
+FROM node:18-alpine AS production
+
+# Create non-root user
+RUN addgroup -g 1001 -S agentx && \\
+    adduser -S agentx -u 1001
+
+WORKDIR /app
+
+# Copy built application
+COPY --from=builder /app/node_modules ./node_modules
+${options.typescript ?
+            'COPY --from=builder /app/dist ./dist' :
+            'COPY --from=builder /app/src ./src'}
+COPY --from=builder /app/package*.json ./
+
+# Set ownership
+RUN chown -R agentx:agentx /app
+USER agentx
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=3s --start-period=5s --retries=3 \\
+  CMD node -e "require('http').get('http://localhost:3000/health', (res) => { process.exit(res.statusCode === 200 ? 0 : 1) })"
+
+# Expose port
+EXPOSE 3000
+
+# Start application
+CMD ["npm", "start"]
+`;
+        fs.writeFileSync(path.join(projectDir, 'Dockerfile'), content);
+    }
+    async generateDockerIgnore(projectDir) {
+        const content = `node_modules
+npm-debug.log
+.env
+.env.local
+.git
+.gitignore
+README.md
+Dockerfile
+.dockerignore
+coverage
+.nyc_output
+`;
+        fs.writeFileSync(path.join(projectDir, '.dockerignore'), content);
+    }
+    async generateDockerCompose(projectDir, options) {
+        const services = [];
+        // Main application service
+        services.push(`  ${options.projectName}:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - NODE_ENV=production
+    env_file:
+      - .env
+    depends_on:${options.integrations.includes('sql') ? '\n      - postgres' : ''}${options.integrations.includes('redis') ? '\n      - redis' : ''}${options.integrations.includes('mongodb') ? '\n      - mongodb' : ''}
+    restart: unless-stopped
+    networks:
+      - agentx-network`);
+        // Add database services based on integrations
+        if (options.integrations.includes('sql')) {
+            services.push(`  postgres:
+    image: postgres:15-alpine
+    environment:
+      POSTGRES_DB: agentx
+      POSTGRES_USER: agentx
+      POSTGRES_PASSWORD: agentx_password
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    ports:
+      - "5432:5432"
+    restart: unless-stopped
+    networks:
+      - agentx-network`);
+        }
+        if (options.integrations.includes('redis')) {
+            services.push(`  redis:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+    volumes:
+      - redis_data:/data
+    restart: unless-stopped
+    networks:
+      - agentx-network`);
+        }
+        if (options.integrations.includes('mongodb')) {
+            services.push(`  mongodb:
+    image: mongo:6
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: agentx
+      MONGO_INITDB_ROOT_PASSWORD: agentx_password
+    volumes:
+      - mongodb_data:/data/db
+    ports:
+      - "27017:27017"
+    restart: unless-stopped
+    networks:
+      - agentx-network`);
+        }
+        // Add monitoring if security features are enabled
+        if (options.security.includes('audit-logging')) {
+            services.push(`  # Uncomment for monitoring
+  # grafana:
+  #   image: grafana/grafana:latest
+  #   ports:
+  #     - "3001:3000"
+  #   environment:
+  #     - GF_SECURITY_ADMIN_PASSWORD=admin
+  #   networks:
+  #     - agentx-network`);
+        }
+        const volumes = [];
+        if (options.integrations.includes('sql'))
+            volumes.push('  postgres_data:');
+        if (options.integrations.includes('redis'))
+            volumes.push('  redis_data:');
+        if (options.integrations.includes('mongodb'))
+            volumes.push('  mongodb_data:');
+        const content = `version: '3.8'
+
+services:
+${services.join('\n\n')}
+
+${volumes.length > 0 ? `volumes:\n${volumes.join('\n')}\n` : ''}
+networks:
+  agentx-network:
+    driver: bridge
+`;
+        fs.writeFileSync(path.join(projectDir, 'docker-compose.yml'), content);
+    }
+    async generateKubernetesManifests(projectDir, options) {
+        const k8sDir = path.join(projectDir, 'k8s');
+        if (!fs.existsSync(k8sDir)) {
+            fs.mkdirSync(k8sDir, { recursive: true });
+        }
+        // Namespace
+        const namespace = `apiVersion: v1
+kind: Namespace
+metadata:
+  name: agentx
+`;
+        // Deployment
+        const deployment = `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: ${options.projectName}
+  namespace: agentx
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: ${options.projectName}
+  template:
+    metadata:
+      labels:
+        app: ${options.projectName}
+    spec:
+      containers:
+      - name: ${options.projectName}
+        image: ${options.projectName}:latest
+        ports:
+        - containerPort: 3000
+        env:
+        - name: NODE_ENV
+          value: "production"
+        envFrom:
+        - secretRef:
+            name: ${options.projectName}-secrets
+        resources:
+          requests:
+            memory: "256Mi"
+            cpu: "250m"
+          limits:
+            memory: "512Mi"
+            cpu: "500m"
+        livenessProbe:
+          httpGet:
+            path: /health
+            port: 3000
+          initialDelaySeconds: 30
+          periodSeconds: 10
+        readinessProbe:
+          httpGet:
+            path: /ready
+            port: 3000
+          initialDelaySeconds: 5
+          periodSeconds: 5
+`;
+        // Service
+        const service = `apiVersion: v1
+kind: Service
+metadata:
+  name: ${options.projectName}-service
+  namespace: agentx
+spec:
+  selector:
+    app: ${options.projectName}
+  ports:
+  - protocol: TCP
+    port: 80
+    targetPort: 3000
+  type: ClusterIP
+`;
+        // Ingress
+        const ingress = `apiVersion: networking.k8s.io/v1
+kind: Ingress
+metadata:
+  name: ${options.projectName}-ingress
+  namespace: agentx
+  annotations:
+    kubernetes.io/ingress.class: nginx
+    cert-manager.io/cluster-issuer: letsencrypt-prod
+spec:
+  tls:
+  - hosts:
+    - ${options.projectName}.yourdomain.com
+    secretName: ${options.projectName}-tls
+  rules:
+  - host: ${options.projectName}.yourdomain.com
+    http:
+      paths:
+      - path: /
+        pathType: Prefix
+        backend:
+          service:
+            name: ${options.projectName}-service
+            port:
+              number: 80
+`;
+        fs.writeFileSync(path.join(k8sDir, '01-namespace.yaml'), namespace);
+        fs.writeFileSync(path.join(k8sDir, '02-deployment.yaml'), deployment);
+        fs.writeFileSync(path.join(k8sDir, '03-service.yaml'), service);
+        fs.writeFileSync(path.join(k8sDir, '04-ingress.yaml'), ingress);
+    }
+    async generateRailwayConfig(projectDir, options) {
+        const content = `{
+  "build": {
+    "builder": "NIXPACKS"
+  },
+  "deploy": {
+    "startCommand": "npm start",
+    "healthcheckPath": "/health",
+    "healthcheckTimeout": 300,
+    "restartPolicyType": "ON_FAILURE",
+    "restartPolicyMaxRetries": 10
+  }
+}
+`;
+        fs.writeFileSync(path.join(projectDir, 'railway.json'), content);
+    }
+    async generateVercelConfig(projectDir, options) {
+        const content = `{
+  "version": 2,
+  "builds": [
+    {
+      "src": "${options.typescript ? 'dist/index.js' : 'src/index.js'}",
+      "use": "@vercel/node"
+    }
+  ],
+  "routes": [
+    {
+      "src": "/(.*)",
+      "dest": "${options.typescript ? 'dist/index.js' : 'src/index.js'}"
+    }
+  ],
+  "env": {
+    "NODE_ENV": "production"
+  }
+}
+`;
+        fs.writeFileSync(path.join(projectDir, 'vercel.json'), content);
+    }
+    async generateLambdaConfig(projectDir, options) {
+        const content = `{
+  "name": "${options.projectName}",
+  "description": "AgentX application deployed on AWS Lambda",
+  "runtime": "nodejs18.x",
+  "handler": "${options.typescript ? 'dist/lambda.handler' : 'src/lambda.handler'}",
+  "timeout": 30,
+  "memorySize": 512,
+  "environment": {
+    "NODE_ENV": "production"
+  },
+  "layers": [],
+  "events": [
+    {
+      "http": {
+        "path": "/{proxy+}",
+        "method": "ANY",
+        "cors": true
+      }
+    }
+  ]
+}
+`;
+        fs.writeFileSync(path.join(projectDir, 'serverless.yml'), content);
+        // Create Lambda handler
+        const ext = options.typescript ? 'ts' : 'js';
+        const lambdaHandler = `/**
+ * AWS Lambda Handler
+ */
+${options.typescript ? "import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';" : ""}
+
+export const handler = async (event${options.typescript ? ': APIGatewayProxyEvent' : ''}, context${options.typescript ? ': Context' : ''})${options.typescript ? ': Promise<APIGatewayProxyResult>' : ''} => {
+  // Initialize your AgentX runtime here
+  // This is a basic example - adapt based on your needs
+  
+  return {
+    statusCode: 200,
+    headers: {
+      'Content-Type': 'application/json',
+      'Access-Control-Allow-Origin': '*',
+    },
+    body: JSON.stringify({
+      message: 'AgentX Lambda function is running',
+      event: event.path,
+    }),
+  };
+};
+`;
+        fs.writeFileSync(path.join(projectDir, 'src', `lambda.${ext}`), lambdaHandler);
+    }
+    async generateSystemdService(projectDir, options) {
+        const content = `[Unit]
+Description=${options.projectName} - AgentX Application
+After=network.target
+
+[Service]
+Type=simple
+User=agentx
+WorkingDirectory=/opt/${options.projectName}
+ExecStart=/usr/bin/npm start
+Restart=on-failure
+RestartSec=10
+StandardOutput=syslog
+StandardError=syslog
+SyslogIdentifier=${options.projectName}
+Environment=NODE_ENV=production
+EnvironmentFile=/opt/${options.projectName}/.env
+
+[Install]
+WantedBy=multi-user.target
+`;
+        fs.writeFileSync(path.join(projectDir, `${options.projectName}.service`), content);
+        // Create installation script
+        const installScript = `#!/bin/bash
+# Installation script for ${options.projectName}
+
+set -e
+
+echo "Installing ${options.projectName} as systemd service..."
+
+# Create user
+sudo useradd -r -s /bin/false agentx || true
+
+# Create directory
+sudo mkdir -p /opt/${options.projectName}
+sudo cp -r . /opt/${options.projectName}/
+sudo chown -R agentx:agentx /opt/${options.projectName}
+
+# Install service
+sudo cp ${options.projectName}.service /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable ${options.projectName}
+
+echo "Installation complete!"
+echo "Start the service with: sudo systemctl start ${options.projectName}"
+echo "Check status with: sudo systemctl status ${options.projectName}"
+`;
+        fs.writeFileSync(path.join(projectDir, 'install.sh'), installScript);
+        // Make install script executable (on Unix systems)
+        try {
+            fs.chmodSync(path.join(projectDir, 'install.sh'), 0o755);
+        }
+        catch (error) {
+            // Ignore on Windows
+        }
+    }
+    /**
+     * Generate security-related files
+     */
+    async generateSecurityFiles(projectDir, options) {
+        if (options.security.includes('https-only')) {
+            await this.generateSecurityHeaders(projectDir);
+        }
+        if (options.security.includes('input-validation')) {
+            await this.generateValidationSchemas(projectDir, options);
+        }
+        if (options.security.includes('audit-logging')) {
+            await this.generateAuditConfig(projectDir);
+        }
+        // Generate security documentation
+        await this.generateSecurityDocs(projectDir, options);
+    }
+    async generateSecurityHeaders(projectDir) {
+        const ext = 'ts'; // Always generate TypeScript for middleware
+        const content = `/**
+ * Security Headers Middleware
+ * Implements security best practices
+ */
+import { Request, Response, NextFunction } from 'express';
+
+export function securityHeaders(req: Request, res: Response, next: NextFunction): void {
+  // Force HTTPS
+  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
+  
+  // Prevent clickjacking
+  res.setHeader('X-Frame-Options', 'DENY');
+  
+  // Prevent MIME type sniffing
+  res.setHeader('X-Content-Type-Options', 'nosniff');
+  
+  // XSS Protection
+  res.setHeader('X-XSS-Protection', '1; mode=block');
+  
+  // Content Security Policy
+  res.setHeader('Content-Security-Policy', 
+    "default-src 'self'; " +
+    "script-src 'self' 'unsafe-inline'; " +
+    "style-src 'self' 'unsafe-inline'; " +
+    "img-src 'self' data: https:; " +
+    "connect-src 'self'; " +
+    "font-src 'self'; " +
+    "object-src 'none'; " +
+    "media-src 'self'; " +
+    "frame-src 'none';"
+  );
+  
+  // Referrer Policy
+  res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+  
+  // Permissions Policy
+  res.setHeader('Permissions-Policy', 
+    'camera=(), microphone=(), geolocation=(), payment=()'
+  );
+
+  next();
+}
+`;
+        const middlewareDir = path.join(projectDir, 'src', 'middleware');
+        if (!fs.existsSync(middlewareDir)) {
+            fs.mkdirSync(middlewareDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(middlewareDir, `security.${ext}`), content);
+    }
+    async generateValidationSchemas(projectDir, options) {
+        const ext = options.typescript ? 'ts' : 'js';
+        const content = `/**
+ * Input Validation Schemas
+ * Define validation rules for all inputs
+ */
+${options.typescript ? "import Joi from 'joi';" : "const Joi = require('joi');"}
+
+// Common validation patterns
+const patterns = {
+  email: Joi.string().email().required(),
+  password: Joi.string().min(8).pattern(/^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[@$!%*?&])[A-Za-z\\d@$!%*?&]/).required(),
+  apiKey: Joi.string().alphanum().length(32).required(),
+  uuid: Joi.string().uuid().required(),
+};
+
+// Agent configuration validation
+export const agentConfigSchema = Joi.object({
+  name: Joi.string().alphanum().min(3).max(50).required(),
+  description: Joi.string().max(500),
+  llmProvider: Joi.string().valid('openai', 'anthropic', 'local').required(),
+  model: Joi.string().required(),
+  systemPrompt: Joi.string().max(2000).required(),
+  temperature: Joi.number().min(0).max(2).default(0.7),
+  maxIterations: Joi.number().integer().min(1).max(50).default(10),
+});
+
+// Workflow validation
+export const workflowSchema = Joi.object({
+  id: Joi.string().alphanum().required(),
+  name: Joi.string().min(3).max(100).required(),
+  version: Joi.string().pattern(/^\\d+\\.\\d+\\.\\d+$/).required(),
+  steps: Joi.array().items(Joi.object({
+    id: Joi.string().required(),
+    name: Joi.string().required(),
+    type: Joi.string().valid('tool', 'condition', 'loop').required(),
+    config: Joi.object().required(),
+  })).min(1).required(),
+});
+
+// API request validation
+export const apiRequestSchema = Joi.object({
+  method: Joi.string().valid('GET', 'POST', 'PUT', 'DELETE', 'PATCH').required(),
+  url: Joi.string().uri().required(),
+  headers: Joi.object().pattern(Joi.string(), Joi.string()),
+  body: Joi.any(),
+  timeout: Joi.number().integer().min(1000).max(30000).default(10000),
+});
+
+${options.typescript ? 'export default { patterns, agentConfigSchema, workflowSchema, apiRequestSchema };' : 'module.exports = { patterns, agentConfigSchema, workflowSchema, apiRequestSchema };'}
+`;
+        const schemasDir = path.join(projectDir, 'src', 'schemas');
+        if (!fs.existsSync(schemasDir)) {
+            fs.mkdirSync(schemasDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(schemasDir, `validation.${ext}`), content);
+    }
+    async generateAuditConfig(projectDir) {
+        const content = `/**
+ * Audit Logging Configuration
+ * Tracks security-relevant events
+ */
+
+export interface AuditEvent {
+  timestamp: string;
+  userId?: string;
+  action: string;
+  resource: string;
+  outcome: 'success' | 'failure';
+  details?: Record<string, any>;
+  ipAddress?: string;
+  userAgent?: string;
+}
+
+export const auditEvents = {
+  // Authentication events
+  LOGIN_SUCCESS: 'auth.login.success',
+  LOGIN_FAILURE: 'auth.login.failure',
+  LOGOUT: 'auth.logout',
+  
+  // API access events
+  API_ACCESS: 'api.access',
+  API_KEY_CREATED: 'api.key.created',
+  API_KEY_REVOKED: 'api.key.revoked',
+  
+  // Agent events
+  AGENT_CREATED: 'agent.created',
+  AGENT_MODIFIED: 'agent.modified',
+  AGENT_DELETED: 'agent.deleted',
+  AGENT_EXECUTED: 'agent.executed',
+  
+  // Workflow events
+  WORKFLOW_CREATED: 'workflow.created',
+  WORKFLOW_EXECUTED: 'workflow.executed',
+  WORKFLOW_FAILED: 'workflow.failed',
+  
+  // Security events
+  RATE_LIMIT_EXCEEDED: 'security.rate_limit.exceeded',
+  INVALID_INPUT: 'security.input.invalid',
+  UNAUTHORIZED_ACCESS: 'security.access.unauthorized',
+};
+
+export class AuditLogger {
+  static log(event: AuditEvent): void {
+    // In production, send to your logging service
+    console.log('[AUDIT]', JSON.stringify(event));
+  }
+  
+  static logAuth(action: string, userId?: string, outcome: 'success' | 'failure' = 'success'): void {
+    this.log({
+      timestamp: new Date().toISOString(),
+      userId,
+      action,
+      resource: 'authentication',
+      outcome,
+    });
+  }
+  
+  static logApiAccess(endpoint: string, userId?: string, outcome: 'success' | 'failure' = 'success'): void {
+    this.log({
+      timestamp: new Date().toISOString(),
+      userId,
+      action: auditEvents.API_ACCESS,
+      resource: endpoint,
+      outcome,
+    });
+  }
+}
+`;
+        const securityDir = path.join(projectDir, 'src', 'security');
+        if (!fs.existsSync(securityDir)) {
+            fs.mkdirSync(securityDir, { recursive: true });
+        }
+        fs.writeFileSync(path.join(securityDir, 'audit.ts'), content);
+    }
+    async generateSecurityDocs(projectDir, options) {
+        const content = `# Security Guide for ${options.projectName}
+
+## Overview
+
+This document outlines the security measures implemented in your AgentX application.
+
+## Implemented Security Features
+
+${options.security.map(feature => {
+            switch (feature) {
+                case 'https-only':
+                    return '### HTTPS Only\n- Strict Transport Security headers\n- Secure cookie settings\n- Content Security Policy';
+                case 'api-keys':
+                    return '### API Key Authentication\n- Secure API key generation\n- Key rotation capabilities\n- Rate limiting per key';
+                case 'jwt':
+                    return '### JWT Authentication\n- Secure token generation\n- Configurable expiration\n- Refresh token support';
+                case 'rate-limiting':
+                    return '### Rate Limiting\n- Per-IP rate limiting\n- Per-user rate limiting\n- Configurable limits';
+                case 'input-validation':
+                    return '### Input Validation\n- Schema-based validation\n- SQL injection prevention\n- XSS protection';
+                case 'audit-logging':
+                    return '### Audit Logging\n- Security event tracking\n- User action logging\n- Compliance reporting';
+                case 'secrets-manager':
+                    return '### Secrets Management\n- External secrets integration\n- Encrypted storage\n- Access control';
+                default:
+                    return `### ${feature}\n- Feature implemented`;
+            }
+        }).join('\n\n')}
+
+## Security Checklist
+
+### Before Production
+
+- [ ] Change all default passwords and API keys
+- [ ] Enable HTTPS with valid SSL certificates
+- [ ] Configure firewall rules
+- [ ] Set up monitoring and alerting
+- [ ] Review and test backup procedures
+- [ ] Conduct security audit
+- [ ] Update dependencies to latest versions
+
+### Environment Variables
+
+Ensure these environment variables are properly configured:
+
+${options.security.includes('jwt') ? '- `JWT_SECRET`: Use a strong, random secret key' : ''}
+${options.security.includes('api-keys') ? '- `MASTER_API_KEY`: Change from default value' : ''}
+${options.features.includes('credentials') ? '- `CREDENTIAL_ENCRYPTION_KEY`: 32-character encryption key' : ''}
+
+### Regular Maintenance
+
+- [ ] Regular security updates
+- [ ] Log monitoring and analysis
+- [ ] Access review and cleanup
+- [ ] Backup testing
+- [ ] Incident response testing
+
+## Deployment Security
+
+${options.deployment.includes('docker') ? `
+### Docker Security
+- Use non-root user in containers
+- Scan images for vulnerabilities
+- Use minimal base images
+- Keep containers updated
+` : ''}
+
+${options.deployment.includes('kubernetes') ? `
+### Kubernetes Security
+- Use network policies
+- Enable RBAC
+- Scan container images
+- Use secrets for sensitive data
+- Regular cluster updates
+` : ''}
+
+## Incident Response
+
+1. **Detection**: Monitor logs and alerts
+2. **Assessment**: Determine scope and impact
+3. **Containment**: Isolate affected systems
+4. **Recovery**: Restore normal operations
+5. **Lessons Learned**: Update procedures
+
+## Contact
+
+For security issues, contact: security@yourcompany.com
+`;
+        fs.writeFileSync(path.join(projectDir, 'SECURITY.md'), content);
+    }
+    /**
+     * Generate payment integration examples
+     */
+    async generatePaymentExamples(projectDir, options) {
+        const paymentsDir = path.join(projectDir, 'src', 'payments');
+        if (!fs.existsSync(paymentsDir)) {
+            fs.mkdirSync(paymentsDir, { recursive: true });
+        }
+        const ext = options.typescript ? 'ts' : 'js';
+        // Generate payment service
+        await this.generatePaymentService(paymentsDir, ext, options.typescript);
+        // Generate M-Pesa specific example
+        await this.generateMPesaExample(paymentsDir, ext, options.typescript);
+        // Generate payment webhook handler
+        await this.generatePaymentWebhooks(paymentsDir, ext, options.typescript);
+        // Generate payment documentation
+        await this.generatePaymentDocs(projectDir);
+    }
+    async generatePaymentService(paymentsDir, ext, typescript) {
+        const imports = typescript
+            ? `import { PaymentProviderRegistry, createPaymentProvider, PaymentRequest, PaymentResult } from 'agentx';
+import { Logger } from 'agentx';`
+            : `const { PaymentProviderRegistry, createPaymentProvider } = require('agentx');`;
+        const content = `/**
+ * Payment Service
+ * Handles all payment operations
+ */
+${imports}
+
+export class PaymentService {
+  private registry${typescript ? ': PaymentProviderRegistry' : ''};
+  private logger${typescript ? ': Logger' : ''};
+
+  constructor(logger${typescript ? ': Logger' : ''}) {
+    this.logger = logger;
+    this.registry = new PaymentProviderRegistry(logger);
+  }
+
+  /**
+   * Initialize payment providers
+   */
+  async initialize()${typescript ? ': Promise<void>' : ''} {
+    // Initialize Stripe
+    if (process.env.STRIPE_SECRET_KEY) {
+      const stripe = createPaymentProvider('stripe', this.logger);
+      await this.registry.register(stripe, {
+        name: 'stripe',
+        credentials: {
+          apiKey: process.env.STRIPE_SECRET_KEY,
+          webhookSecret: process.env.STRIPE_WEBHOOK_SECRET,
+        },
+        environment: process.env.NODE_ENV === 'production' ? 'production' : 'test',
+      });
+    }
+
+    // Initialize PayPal
+    if (process.env.PAYPAL_CLIENT_ID) {
+      const paypal = createPaymentProvider('paypal', this.logger);
+      await this.registry.register(paypal, {
+        name: 'paypal',
+        credentials: {
+          clientId: process.env.PAYPAL_CLIENT_ID,
+          clientSecret: process.env.PAYPAL_CLIENT_SECRET,
+        },
+        environment: process.env.PAYPAL_MODE || 'sandbox',
+      });
+    }
+
+    // Initialize M-Pesa
+    if (process.env.MPESA_CONSUMER_KEY) {
+      const mpesa = createPaymentProvider('mpesa', this.logger);
+      await this.registry.register(mpesa, {
+        name: 'mpesa',
+        credentials: {
+          consumerKey: process.env.MPESA_CONSUMER_KEY,
+          consumerSecret: process.env.MPESA_CONSUMER_SECRET,
+          shortcode: process.env.MPESA_SHORTCODE,
+          passkey: process.env.MPESA_PASSKEY,
+        },
+        environment: process.env.MPESA_ENVIRONMENT || 'sandbox',
+        callbackUrl: process.env.MPESA_CALLBACK_URL,
+        webhookUrl: process.env.MPESA_WEBHOOK_URL,
+      });
+    }
+
+    this.logger.info('Payment service initialized');
+  }
+
+  /**
+   * Process payment with specified provider
+   */
+  async processPayment(
+    providerName${typescript ? ': string' : ''}, 
+    request${typescript ? ': PaymentRequest' : ''}
+  )${typescript ? ': Promise<PaymentResult>' : ''} {
+    const provider = this.registry.get(providerName);
+    if (!provider) {
+      throw new Error(\`Payment provider not found: \${providerName}\`);
+    }
+
+    return await provider.processPayment(request);
+  }
+
+  /**
+   * Get available payment providers
+   */
+  getAvailableProviders()${typescript ? ': string[]' : ''} {
+    return this.registry.list();
+  }
+
+  /**
+   * Get payment status
+   */
+  async getPaymentStatus(
+    providerName${typescript ? ': string' : ''}, 
+    paymentId${typescript ? ': string' : ''}
+  )${typescript ? ': Promise<string>' : ''} {
+    const provider = this.registry.get(providerName);
+    if (!provider) {
+      throw new Error(\`Payment provider not found: \${providerName}\`);
+    }
+
+    return await provider.getPaymentStatus(paymentId);
+  }
+}
+`;
+        fs.writeFileSync(path.join(paymentsDir, `PaymentService.${ext}`), content);
+    }
+    async generateMPesaExample(paymentsDir, ext, typescript) {
+        const imports = typescript
+            ? `import { PaymentService } from './PaymentService';
+import { Logger } from 'agentx';`
+            : `const { PaymentService } = require('./PaymentService');`;
+        const content = `/**
+ * M-Pesa Payment Example
+ * Complete working example for M-Pesa STK Push
+ */
+${imports}
+
+export class MPesaPaymentExample {
+  private paymentService${typescript ? ': PaymentService' : ''};
+  private logger${typescript ? ': Logger' : ''};
+
+  constructor(logger${typescript ? ': Logger' : ''}) {
+    this.logger = logger;
+    this.paymentService = new PaymentService(logger);
+  }
+
+  /**
+   * Initialize M-Pesa payment service
+   */
+  async initialize()${typescript ? ': Promise<void>' : ''} {
+    await this.paymentService.initialize();
+  }
+
+  /**
+   * Process M-Pesa STK Push payment
+   * @param phoneNumber - Customer phone number (254XXXXXXXXX format)
+   * @param amount - Amount in KES
+   * @param accountReference - Account reference (optional)
+   * @param description - Transaction description
+   */
+  async processMPesaPayment(
+    phoneNumber${typescript ? ': string' : ''}, 
+    amount${typescript ? ': number' : ''}, 
+    accountReference${typescript ? ': string' : ''} = 'Payment',
+    description${typescript ? ': string' : ''} = 'Payment for services'
+  )${typescript ? ': Promise<any>' : ''} {
+    try {
+      // Validate phone number format
+      const formattedPhone = this.formatPhoneNumber(phoneNumber);
+      
+      const paymentRequest = {
+        amount,
+        currency: 'KES',
+        paymentMethod: {
+          type: 'mobile_money',
+          provider: 'mpesa',
+          details: {
+            phoneNumber: formattedPhone,
+            accountReference,
+            transactionDesc: description,
+          },
+        },
+        metadata: {
+          phoneNumber: formattedPhone,
+          accountReference,
+        },
+        description,
+        callbackUrl: process.env.MPESA_CALLBACK_URL,
+      };
+
+      const result = await this.paymentService.processPayment('mpesa', paymentRequest);
+      
+      this.logger.info('M-Pesa payment initiated', {
+        paymentId: result.paymentId,
+        phoneNumber: formattedPhone,
+        amount,
+      });
+
+      return {
+        success: result.success,
+        paymentId: result.paymentId,
+        message: result.success 
+          ? 'Payment request sent. Please check your phone for M-Pesa prompt.'
+          : 'Payment failed. Please try again.',
+        error: result.error,
+      };
+    } catch (error) {
+      this.logger.error('M-Pesa payment error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Check M-Pesa payment status
+   */
+  async checkPaymentStatus(paymentId${typescript ? ': string' : ''})${typescript ? ': Promise<string>' : ''} {
+    try {
+      const status = await this.paymentService.getPaymentStatus('mpesa', paymentId);
+      this.logger.info('M-Pesa payment status checked', { paymentId, status });
+      return status;
+    } catch (error) {
+      this.logger.error('M-Pesa status check error', error);
+      throw error;
+    }
+  }
+
+  /**
+   * Format phone number to M-Pesa format (254XXXXXXXXX)
+   */
+  private formatPhoneNumber(phone${typescript ? ': string' : ''})${typescript ? ': string' : ''} {
+    // Remove all non-digits
+    let formatted = phone.replace(/\\D/g, '');
+    
+    // Handle different formats
+    if (formatted.startsWith('0')) {
+      // Convert 07XXXXXXXX to 2547XXXXXXXX
+      formatted = '254' + formatted.slice(1);
+    } else if (formatted.startsWith('7')) {
+      // Convert 7XXXXXXXX to 2547XXXXXXXX
+      formatted = '254' + formatted;
+    } else if (!formatted.startsWith('254')) {
+      // Assume it needs 254 prefix
+      formatted = '254' + formatted;
+    }
+    
+    // Validate length (should be 12 digits: 254XXXXXXXXX)
+    if (formatted.length !== 12) {
+      throw new Error('Invalid phone number format. Expected format: 254XXXXXXXXX');
+    }
+    
+    return formatted;
+  }
+
+  /**
+   * Example usage function
+   */
+  static async example()${typescript ? ': Promise<void>' : ''} {
+    const logger${typescript ? ': Logger' : ''} = {
+      debug: (msg${typescript ? ': string' : ''}) => console.log(\`[DEBUG] \${msg}\`),
+      info: (msg${typescript ? ': string' : ''}) => console.log(\`[INFO] \${msg}\`),
+      warn: (msg${typescript ? ': string' : ''}) => console.warn(\`[WARN] \${msg}\`),
+      error: (msg${typescript ? ': string' : ''}) => console.error(\`[ERROR] \${msg}\`),
+    };
+
+    const mpesa = new MPesaPaymentExample(logger);
+    await mpesa.initialize();
+
+    // Example: Process payment
+    try {
+      const result = await mpesa.processMPesaPayment(
+        '0712345678', // Phone number
+        100,          // Amount in KES
+        'ORDER123',   // Account reference
+        'Payment for Order #123'
+      );
+      
+      console.log('Payment Result:', result);
+      
+      // Check status after a delay
+      if (result.success && result.paymentId) {
+        setTimeout(async () => {
+          const status = await mpesa.checkPaymentStatus(result.paymentId);
+          console.log('Payment Status:', status);
+        }, 5000);
+      }
+    } catch (error) {
+      console.error('Payment failed:', error);
+    }
+  }
+}
+
+// Uncomment to run example
+// MPesaPaymentExample.example();
+`;
+        fs.writeFileSync(path.join(paymentsDir, `MPesaExample.${ext}`), content);
+    }
+    async generatePaymentWebhooks(paymentsDir, ext, typescript) {
+        const imports = typescript
+            ? `import { Request, Response } from 'express';
+import { PaymentProviderRegistry } from 'agentx';`
+            : `// const express = require('express');`;
+        const content = `/**
+ * Payment Webhook Handlers
+ * Handle webhooks from payment providers
+ */
+${imports}
+
+export class PaymentWebhookHandler {
+  private registry${typescript ? ': PaymentProviderRegistry' : ''};
+
+  constructor(registry${typescript ? ': PaymentProviderRegistry' : ''}) {
+    this.registry = registry;
+  }
+
+  /**
+   * Handle M-Pesa callback webhook
+   */
+  async handleMPesaCallback(req${typescript ? ': Request' : ''}, res${typescript ? ': Response' : ''})${typescript ? ': Promise<void>' : ''} {
+    try {
+      const payload = req.body;
+      console.log('M-Pesa Callback received:', JSON.stringify(payload, null, 2));
+
+      const mpesa = this.registry.get('mpesa');
+      if (!mpesa) {
+        throw new Error('M-Pesa provider not initialized');
+      }
+
+      // Validate and process webhook
+      const isValid = await mpesa.validateWebhook(payload, '');
+      if (!isValid) {
+        return res.status(400).json({ error: 'Invalid webhook' });
+      }
+
+      const result = await mpesa.processWebhook(payload);
+      
+      if (result.processed) {
+        // Handle successful payment
+        const callback = payload.Body?.stkCallback;
+        if (callback?.ResultCode === 0) {
+          console.log('Payment successful:', {
+            paymentId: callback.CheckoutRequestID,
+            mpesaReceiptNumber: callback.CallbackMetadata?.Item?.find((item${typescript ? ': any' : ''}) => item.Name === 'MpesaReceiptNumber')?.Value,
+            amount: callback.CallbackMetadata?.Item?.find((item${typescript ? ': any' : ''}) => item.Name === 'Amount')?.Value,
+            phoneNumber: callback.CallbackMetadata?.Item?.find((item${typescript ? ': any' : ''}) => item.Name === 'PhoneNumber')?.Value,
+          });
+          
+          // TODO: Update your database with payment success
+          // await updatePaymentStatus(callback.CheckoutRequestID, 'completed');
+        } else {
+          console.log('Payment failed:', {
+            paymentId: callback.CheckoutRequestID,
+            errorCode: callback.ResultCode,
+            errorMessage: callback.ResultDesc,
+          });
+          
+          // TODO: Update your database with payment failure
+          // await updatePaymentStatus(callback.CheckoutRequestID, 'failed');
+        }
+      }
+
+      res.status(200).json({ message: 'Webhook processed successfully' });
+    } catch (error) {
+      console.error('M-Pesa webhook error:', error);
+      res.status(500).json({ error: 'Webhook processing failed' });
+    }
+  }
+
+  /**
+   * Handle Stripe webhook
+   */
+  async handleStripeWebhook(req${typescript ? ': Request' : ''}, res${typescript ? ': Response' : ''})${typescript ? ': Promise<void>' : ''} {
+    try {
+      const signature = req.headers['stripe-signature']${typescript ? ' as string' : ''};
+      const payload = req.body;
+
+      const stripe = this.registry.get('stripe');
+      if (!stripe) {
+        throw new Error('Stripe provider not initialized');
+      }
+
+      const isValid = await stripe.validateWebhook(payload, signature);
+      if (!isValid) {
+        return res.status(400).json({ error: 'Invalid webhook signature' });
+      }
+
+      const result = await stripe.processWebhook(payload);
+      console.log('Stripe webhook processed:', result);
+
+      res.status(200).json({ received: true });
+    } catch (error) {
+      console.error('Stripe webhook error:', error);
+      res.status(500).json({ error: 'Webhook processing failed' });
+    }
+  }
+
+  /**
+   * Handle PayPal webhook
+   */
+  async handlePayPalWebhook(req${typescript ? ': Request' : ''}, res${typescript ? ': Response' : ''})${typescript ? ': Promise<void>' : ''} {
+    try {
+      const payload = req.body;
+
+      const paypal = this.registry.get('paypal');
+      if (!paypal) {
+        throw new Error('PayPal provider not initialized');
+      }
+
+      const result = await paypal.processWebhook(payload);
+      console.log('PayPal webhook processed:', result);
+
+      res.status(200).json({ received: true });
+    } catch (error) {
+      console.error('PayPal webhook error:', error);
+      res.status(500).json({ error: 'Webhook processing failed' });
+    }
+  }
+}
+
+/**
+ * Express.js route setup example
+ */
+export function setupPaymentRoutes(app${typescript ? ': any' : ''}, webhookHandler${typescript ? ': PaymentWebhookHandler' : ''})${typescript ? ': void' : ''} {
+  // M-Pesa callback endpoint
+  app.post('/api/payments/mpesa/callback', (req${typescript ? ': Request' : ''}, res${typescript ? ': Response' : ''}) => {
+    webhookHandler.handleMPesaCallback(req, res);
+  });
+
+  // Stripe webhook endpoint
+  app.post('/api/payments/stripe/webhook', (req${typescript ? ': Request' : ''}, res${typescript ? ': Response' : ''}) => {
+    webhookHandler.handleStripeWebhook(req, res);
+  });
+
+  // PayPal webhook endpoint
+  app.post('/api/payments/paypal/webhook', (req${typescript ? ': Request' : ''}, res${typescript ? ': Response' : ''}) => {
+    webhookHandler.handlePayPalWebhook(req, res);
+  });
+}
+`;
+        fs.writeFileSync(path.join(paymentsDir, `WebhookHandler.${ext}`), content);
+    }
+    async generatePaymentDocs(projectDir) {
+        const content = `# Payment Integration Guide
+
+## Overview
+
+This project includes complete payment integration with Stripe, PayPal, and M-Pesa (Safaricom). All providers are production-ready and only require API credentials to be configured.
+
+## Supported Payment Providers
+
+### 1. M-Pesa (Safaricom)
+- **Type**: Mobile Money
+- **Currency**: KES (Kenyan Shillings)
+- **Features**: STK Push, Payment Status Checking, Webhooks
+- **Use Case**: Kenya mobile payments
+
+### 2. Stripe
+- **Type**: Credit/Debit Cards, Bank Transfers
+- **Currencies**: USD, EUR, GBP, CAD, AUD, JPY
+- **Features**: Full payment lifecycle, refunds, webhooks
+- **Use Case**: Global card payments
+
+### 3. PayPal
+- **Type**: Digital Wallet, Cards
+- **Currencies**: USD, EUR, GBP, CAD, AUD
+- **Features**: PayPal wallet, card processing, refunds
+- **Use Case**: Global digital payments
+
+## Quick Start
+
+### 1. Configure Environment Variables
+
+Copy the values from \`.env.example\` to \`.env\` and fill in your credentials:
+
+\`\`\`bash
+# M-Pesa Configuration
+MPESA_CONSUMER_KEY=your-consumer-key
+MPESA_CONSUMER_SECRET=your-consumer-secret
+MPESA_SHORTCODE=174379
+MPESA_PASSKEY=your-passkey
+MPESA_ENVIRONMENT=sandbox
+MPESA_CALLBACK_URL=https://yourdomain.com/api/payments/mpesa/callback
+\`\`\`
+
+### 2. Initialize Payment Service
+
+\`\`\`typescript
+import { PaymentService } from './src/payments/PaymentService';
+
+const paymentService = new PaymentService(logger);
+await paymentService.initialize();
+\`\`\`
+
+### 3. Process M-Pesa Payment
+
+\`\`\`typescript
+import { MPesaPaymentExample } from './src/payments/MPesaExample';
+
+const mpesa = new MPesaPaymentExample(logger);
+await mpesa.initialize();
+
+const result = await mpesa.processMPesaPayment(
+  '0712345678',           // Phone number
+  100,                    // Amount in KES
+  'ORDER123',            // Account reference
+  'Payment for services' // Description
+);
+
+console.log('Payment initiated:', result);
+\`\`\`
+
+## M-Pesa Integration Details
+
+### Getting M-Pesa Credentials
+
+1. **Register on Safaricom Developer Portal**
+   - Visit: https://developer.safaricom.co.ke/
+   - Create an account and verify your email
+
+2. **Create an App**
+   - Go to "My Apps" and create a new app
+   - Select "Lipa Na M-Pesa Online" product
+   - Get your Consumer Key and Consumer Secret
+
+3. **Get Shortcode and Passkey**
+   - For sandbox: Use test shortcode 174379
+   - For production: Apply for your business shortcode
+   - Passkey is provided when you get your shortcode
+
+### Phone Number Format
+
+M-Pesa requires phone numbers in international format:
+- ✅ Correct: \`254712345678\`
+- ❌ Wrong: \`0712345678\`, \`+254712345678\`, \`712345678\`
+
+The \`MPesaExample\` class automatically formats phone numbers for you.
+
+### Webhook Setup
+
+1. **Configure Callback URL**
+   - Set \`MPESA_CALLBACK_URL\` to your webhook endpoint
+   - Must be HTTPS in production
+   - Example: \`https://yourdomain.com/api/payments/mpesa/callback\`
+
+2. **Handle Webhooks**
+   \`\`\`typescript
+   import { PaymentWebhookHandler } from './src/payments/WebhookHandler';
+   
+   const webhookHandler = new PaymentWebhookHandler(paymentRegistry);
+   app.post('/api/payments/mpesa/callback', webhookHandler.handleMPesaCallback);
+   \`\`\`
+
+### Testing M-Pesa
+
+1. **Sandbox Testing**
+   - Use test credentials from Safaricom
+   - Use test phone numbers: 254708374149, 254711XXXXXX
+   - No real money is charged
+
+2. **Production Testing**
+   - Use real credentials
+   - Test with small amounts first
+   - Real money will be charged
+
+## Error Handling
+
+All payment methods include comprehensive error handling:
+
+\`\`\`typescript
+try {
+  const result = await mpesa.processMPesaPayment('0712345678', 100);
+  if (result.success) {
+    console.log('Payment initiated successfully');
+  } else {
+    console.error('Payment failed:', result.error);
+  }
+} catch (error) {
+  console.error('Payment error:', error.message);
+}
+\`\`\`
+
+## Security Best Practices
+
+1. **Environment Variables**
+   - Never commit API keys to version control
+   - Use different credentials for sandbox/production
+   - Rotate keys regularly
+
+2. **Webhook Security**
+   - Validate webhook signatures
+   - Use HTTPS for all webhook URLs
+   - Implement idempotency for webhook processing
+
+3. **Error Logging**
+   - Log all payment attempts
+   - Monitor failed payments
+   - Set up alerts for unusual activity
+
+## Production Checklist
+
+- [ ] M-Pesa production credentials configured
+- [ ] Webhook URLs are HTTPS
+- [ ] Error monitoring set up
+- [ ] Payment logging implemented
+- [ ] Backup payment method available
+- [ ] Customer support process defined
+- [ ] Refund process documented
+
+## Support
+
+- **M-Pesa**: developer.safaricom.co.ke
+- **Stripe**: stripe.com/docs
+- **PayPal**: developer.paypal.com
+
+For implementation questions, check the example files in \`src/payments/\`.
+`;
+        fs.writeFileSync(path.join(projectDir, 'PAYMENTS.md'), content);
+    }
+    getPersonalityPrompt(personality) {
+        const presets = {
+            helpful: 'You are a helpful AI assistant. You are friendly, supportive, and always try to provide useful information.',
+            professional: 'You are a professional AI assistant. You communicate formally and focus on business objectives.',
+            concise: 'You are a concise AI assistant. You provide brief, direct answers without unnecessary elaboration.',
+            creative: 'You are a creative AI assistant. You think outside the box and offer imaginative solutions.',
+        };
+        return presets[personality] || personality;
+    }
+    getDefaultModel(provider) {
+        const models = {
+            openai: 'gpt-4',
+            anthropic: 'claude-3-opus-20240229',
+            local: 'llama2',
+        };
+        return models[provider] || 'gpt-4';
+    }
+    escapeString(str) {
+        return str.replace(/'/g, "\\'").replace(/\n/g, '\\n');
+    }
+    printNextSteps(options) {
+        const deploymentInstructions = this.getDeploymentInstructions(options);
+        console.log(`
+╔═══════════════════════════════════════════════════════════╗
+║                     🎉 Success!                           ║
+╚═══════════════════════════════════════════════════════════╝
+
+Next steps:
+
+  cd ${options.projectName}
+  npm install
+  
+  # Configure your environment
+  # Edit .env with your API keys and settings
+  
+  ${options.typescript ? 'npm run dev' : 'npm start'}
+
+${deploymentInstructions}
+
+Security Notes:
+${options.security.includes('https-only') ? '  ✅ HTTPS security headers configured' : ''}
+${options.security.includes('input-validation') ? '  ✅ Input validation schemas created' : ''}
+${options.security.includes('jwt') ? '  ✅ JWT authentication ready' : ''}
+${options.security.includes('rate-limiting') ? '  ✅ Rate limiting configured' : ''}
+${options.security.includes('audit-logging') ? '  ✅ Audit logging enabled' : ''}
+
+📚 Documentation: 
+  - README.md - Getting started guide
+  - SECURITY.md - Security configuration
+${options.features.includes('payments') ? '  - PAYMENTS.md - Complete payment integration guide' : ''}
+${options.deployment.length > 0 ? '  - Deployment files in project root' : ''}
+
+🔗 Resources:
+  - AgentX Docs: https://agentx.dev/docs
+  - Community: https://github.com/agentx/community
+`);
+    }
+    getDeploymentInstructions(options) {
+        if (options.deployment.length === 0)
+            return '';
+        const instructions = ['Deployment Options:'];
+        if (options.deployment.includes('docker')) {
+            instructions.push('  🐳 Docker: npm run docker:build && npm run docker:run');
+        }
+        if (options.deployment.includes('docker-compose')) {
+            instructions.push('  🐙 Docker Compose: npm run compose:up');
+        }
+        if (options.deployment.includes('kubernetes')) {
+            instructions.push('  ☸️  Kubernetes: npm run k8s:deploy');
+        }
+        if (options.deployment.includes('railway')) {
+            instructions.push('  🚂 Railway: Connect your GitHub repo at railway.app');
+        }
+        if (options.deployment.includes('vercel')) {
+            instructions.push('  ▲ Vercel: vercel --prod');
+        }
+        if (options.deployment.includes('aws-lambda')) {
+            instructions.push('  λ AWS Lambda: Use serverless framework or AWS SAM');
+        }
+        if (options.deployment.includes('systemd')) {
+            instructions.push('  🐧 Linux Service: sudo ./install.sh');
+        }
+        return instructions.join('\n');
+    }
+}
+exports.ProjectGenerator = ProjectGenerator;
+//# sourceMappingURL=InteractiveSetup.js.map