@ayurak/aribot-cli 1.0.5 → 1.0.8

package/src/cli.ts

@@ -1,6 +1,15 @@
 #!/usr/bin/env node
 /**
- * Aribot CLI - AI-Powered Threat Modeling
+ * Aribot CLI - Economic, Regulatory & Security APIs for Modern Applications
+ *
+ * Analyze your tech stack. Optimize architecture. Model costs. Identify threats dynamically.
+ *
+ * Features:
+ *   - Advanced Threat Modeling (STRIDE, PASTA, NIST, Aristiun Framework)
+ *   - 100+ Compliance Standards (SOC2, ISO27001, PCI-DSS, GDPR, HIPAA...)
+ *   - Cloud Security (CSPM/CNAPP)
+ *   - Economic Intelligence & FinOps
+ *   - Red Team Automation
  *
  * Usage:
  *   aribot login                    # Authenticate with API key
@@ -26,7 +35,7 @@ const program = new Command();
 
 program
   .name('aribot')
-  .description('AI-powered threat modeling CLI by Ayurak')
+  .description('Aribot - Economic, Regulatory & Security APIs for Modern Applications')
   .version('1.0.5');
 
 // Helper to get auth headers
@@ -57,6 +66,24 @@ async function apiRequest(endpoint: string, options: any = {}): Promise<any> {
   return response.json();
 }
 
+// Resolve short UUID to full UUID
+async function resolveDiagramId(shortId: string): Promise<string> {
+  // If it already looks like a full UUID, return it
+  if (shortId.includes('-') || shortId.length >= 32) {
+    return shortId;
+  }
+
+  // Fetch diagrams and find by prefix match
+  const data = await apiRequest('/v2/threat-modeling/diagrams/?limit=100');
+  const match = data.results?.find((d: any) => d.id.startsWith(shortId));
+
+  if (!match) {
+    throw new Error(`No diagram found matching ID: ${shortId}`);
+  }
+
+  return match.id;
+}
+
 // Login command
 program
   .command('login')
@@ -213,7 +240,10 @@ program
     const spinner = ora('Fetching threats...').start();
 
     try {
-      let url = `/v2/threat-modeling/diagrams/${diagramId}/threats/`;
+      // Resolve short UUID to full UUID
+      const fullId = await resolveDiagramId(diagramId);
+
+      let url = `/v2/threat-modeling/diagrams/${fullId}/threats/`;
       if (options.severity) {
         url += `?severity=${options.severity}`;
       }
@@ -255,19 +285,32 @@ program
     const spinner = ora(`Exporting ${options.format.toUpperCase()} report...`).start();
 
     try {
+      // Resolve short UUID to full UUID
+      const fullId = await resolveDiagramId(diagramId);
+
       const fetch = (await import('node-fetch')).default;
-      const apiKey = config.get('apiKey') as string;
+      const headers = getHeaders();
+
+      // Choose endpoint based on format
+      let endpoint: string;
+      if (options.format === 'csv') {
+        endpoint = `/v2/threat-modeling/diagrams/${fullId}/export/csv/`;
+      } else if (options.format === 'pdf') {
+        endpoint = `/v2/threat-modeling/diagrams/${fullId}/unified-report/?format=pdf`;
+      } else {
+        endpoint = `/v2/threat-modeling/diagrams/${fullId}/report/`;
+      }
 
       const response = await fetch(
-        `${API_BASE}/v2/threat-modeling/diagrams/${diagramId}/export/?format=${options.format}`,
-        { headers: { 'Authorization': `Bearer ${apiKey}` } }
+        `${API_BASE}${endpoint}`,
+        { headers }
       );
 
       if (!response.ok) {
         throw new Error(`Export failed: ${response.status}`);
       }
 
-      const outputPath = options.output || `aribot-report-${diagramId.slice(0, 8)}.${options.format}`;
+      const outputPath = options.output || `aribot-report-${fullId.slice(0, 8)}.${options.format}`;
 
       if (options.format === 'json') {
         const data = await response.json();
@@ -292,7 +335,10 @@ program
     const spinner = ora('Generating AI threats...').start();
 
     try {
-      await apiRequest(`/v2/threat-modeling/diagrams/${diagramId}/generate-threats/`, {
+      // Resolve short UUID to full UUID
+      const fullId = await resolveDiagramId(diagramId);
+
+      await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/generate-threats/`, {
         method: 'POST'
       });
 
@@ -302,7 +348,7 @@ program
       let attempts = 0;
       while (attempts < 30) {
         await new Promise(r => setTimeout(r, 2000));
-        const status = await apiRequest(`/v2/threat-modeling/diagrams/${diagramId}/`);
+        const status = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/`);
 
         if (status.ai_threats_generated) {
           spinner.succeed(`Generated ${status.threats_count} threats`);
@@ -348,4 +394,1213 @@ program
     }
   });
 
+// Status command - Check API status and rate limits
+program
+  .command('status')
+  .description('Check API status and rate limits')
+  .action(async () => {
+    const spinner = ora('Checking API status...').start();
+
+    try {
+      const fetch = (await import('node-fetch')).default;
+
+      // Check health endpoint (no auth required)
+      const healthResponse = await fetch(`${API_BASE}/health/`);
+      const health = await healthResponse.json() as any;
+
+      spinner.stop();
+      console.log(chalk.bold('\nAPI Status:\n'));
+      console.log(`  Status:   ${health.status === 'healthy' ? chalk.green('✓ Healthy') : chalk.red('✗ Unhealthy')}`);
+      console.log(`  Version:  ${chalk.cyan(health.version || 'N/A')}`);
+      console.log(`  Features: ${health.features_enabled ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+
+      // Check rate limits if authenticated
+      const apiKey = config.get('apiKey') as string;
+      if (apiKey) {
+        try {
+          const limits = await apiRequest('/v2/developer-portal/rate-limits/usage/');
+          console.log(chalk.bold('\nRate Limits:\n'));
+          console.log(`  Requests/min:   ${limits.requests_per_minute?.used || 0}/${limits.requests_per_minute?.limit || 'unlimited'}`);
+          console.log(`  Requests/hour:  ${limits.requests_per_hour?.used || 0}/${limits.requests_per_hour?.limit || 'unlimited'}`);
+          console.log(`  Requests/day:   ${limits.requests_per_day?.used || 0}/${limits.requests_per_day?.limit || 'unlimited'}`);
+        } catch {
+          console.log(chalk.dim('\nRate limit info requires authentication'));
+        }
+      }
+    } catch (error) {
+      spinner.fail('Failed to check status');
+      console.error(error);
+    }
+  });
+
+// Compliance command - Run compliance assessment
+program
+  .command('compliance')
+  .description('Run compliance assessment on a diagram')
+  .argument('[diagram-id]', 'Diagram ID to assess')
+  .option('-s, --standard <standard>', 'Compliance standard (SOC2, ISO27001, NIST, PCI-DSS, GDPR, HIPAA)', 'SOC2')
+  .option('--list-standards', 'List all available compliance standards')
+  .action(async (diagramId, options) => {
+    if (options.listStandards) {
+      console.log(chalk.bold('\nSupported Compliance Standards:\n'));
+      const standards = [
+        'SOC2', 'ISO27001', 'ISO27017', 'ISO27018', 'ISO22301',
+        'NIST-CSF', 'NIST-800-53', 'NIST-800-171',
+        'PCI-DSS', 'PCI-DSS-4.0',
+        'GDPR', 'CCPA', 'LGPD', 'PIPEDA',
+        'HIPAA', 'HITRUST',
+        'FedRAMP-Low', 'FedRAMP-Moderate', 'FedRAMP-High',
+        'CIS-AWS', 'CIS-Azure', 'CIS-GCP', 'CIS-Kubernetes',
+        'SOX', 'GLBA', 'FISMA',
+        'CSA-CCM', 'MITRE-ATT&CK', 'OWASP-TOP-10',
+      ];
+      standards.forEach(s => console.log(`  ${chalk.cyan('•')} ${s}`));
+      return;
+    }
+
+    if (!diagramId) {
+      console.error(chalk.red('Error: diagram-id is required for compliance assessment'));
+      console.log(chalk.dim('Usage: aribot compliance <diagram-id> --standard SOC2'));
+      console.log(chalk.dim('       aribot compliance --list-standards'));
+      process.exit(1);
+    }
+
+    const spinner = ora(`Running ${options.standard} compliance assessment...`).start();
+
+    try {
+      // Resolve short UUID to full UUID
+      const fullId = await resolveDiagramId(diagramId);
+
+      const data = await apiRequest('/v2/compliances/assess_diagram/', {
+        method: 'POST',
+        body: JSON.stringify({
+          diagram_id: fullId,
+          frameworks: [options.standard]
+        })
+      });
+
+      spinner.succeed('Compliance assessment complete!');
+
+      console.log(chalk.bold(`\n${options.standard} Compliance Report:\n`));
+      console.log(`  Score:           ${data.score >= 80 ? chalk.green(data.score + '%') : data.score >= 60 ? chalk.yellow(data.score + '%') : chalk.red(data.score + '%')}`);
+      console.log(`  Passed Controls: ${chalk.green(data.passed_controls || 0)}`);
+      console.log(`  Failed Controls: ${chalk.red(data.failed_controls || 0)}`);
+      console.log(`  Status:          ${data.status === 'compliant' ? chalk.green('Compliant') : chalk.yellow('Non-Compliant')}`);
+
+      if (data.findings?.length > 0) {
+        console.log(chalk.bold('\nTop Findings:\n'));
+        data.findings.slice(0, 5).forEach((f: any) => {
+          const severityColor = f.severity === 'high' ? chalk.red : f.severity === 'medium' ? chalk.yellow : chalk.dim;
+          console.log(`  ${severityColor(`[${f.severity?.toUpperCase()}]`)} ${f.title || f.control_id}`);
+        });
+      }
+    } catch (error) {
+      spinner.fail('Compliance assessment failed');
+      console.error(error);
+    }
+  });
+
+// Economics command - Calculate ROI, TCO, cost analysis
+program
+  .command('economics')
+  .description('Economic intelligence and cost analysis')
+  .option('--roi <investment>', 'Calculate ROI for security investment (in USD)')
+  .option('--tco <provider>', 'Calculate TCO for cloud provider (aws, azure, gcp)')
+  .option('--analyze <diagram-id>', 'Analyze costs for a diagram')
+  .option('--dashboard', 'Show economic intelligence dashboard')
+  .action(async (options) => {
+    const spinner = ora('Calculating...').start();
+
+    try {
+      if (options.roi) {
+        const investment = parseFloat(options.roi);
+        const data = await apiRequest('/v2/economic/v2/roi/create/', {
+          method: 'POST',
+          body: JSON.stringify({
+            investment,
+            risk_reduction: 50,
+            time_horizon: 3
+          })
+        });
+
+        spinner.succeed('ROI Analysis Complete!');
+        console.log(chalk.bold('\nSecurity ROI Analysis:\n'));
+        console.log(`  Investment:      ${chalk.cyan('$' + investment.toLocaleString())}`);
+        console.log(`  Expected ROI:    ${chalk.green((data.roi_percentage || data.roi || 0) + '%')}`);
+        console.log(`  NPV:             ${chalk.green('$' + (data.npv || 0).toLocaleString())}`);
+        console.log(`  Payback Period:  ${chalk.cyan((data.payback_months || data.payback_period || 0) + ' months')}`);
+        console.log(`  Risk Reduction:  ${chalk.green('50%')}`);
+
+      } else if (options.tco) {
+        const data = await apiRequest('/v2/economic/tco/', {
+          method: 'POST',
+          body: JSON.stringify({
+            provider: options.tco,
+            workload_type: 'general',
+            duration_months: 36
+          })
+        });
+
+        spinner.succeed('TCO Analysis Complete!');
+        console.log(chalk.bold(`\nTotal Cost of Ownership (${options.tco.toUpperCase()}):\n`));
+        console.log(`  Monthly Cost:    ${chalk.cyan('$' + (data.monthly_cost || 0).toLocaleString())}`);
+        console.log(`  Annual Cost:     ${chalk.cyan('$' + (data.annual_cost || 0).toLocaleString())}`);
+        console.log(`  3-Year TCO:      ${chalk.yellow('$' + (data.total_cost || data.tco || 0).toLocaleString())}`);
+
+      } else if (options.analyze) {
+        const data = await apiRequest('/v2/economic/analyze/', {
+          method: 'POST',
+          body: JSON.stringify({ diagram_id: options.analyze })
+        });
+
+        spinner.succeed('Cost Analysis Complete!');
+        console.log(chalk.bold('\nDiagram Cost Analysis:\n'));
+        console.log(`  Estimated Monthly: ${chalk.cyan('$' + (data.monthly_estimate || 0).toLocaleString())}`);
+        console.log(`  Security Costs:    ${chalk.yellow('$' + (data.security_cost || 0).toLocaleString())}`);
+        console.log(`  Breach Risk Cost:  ${chalk.red('$' + (data.breach_risk_cost || 0).toLocaleString())}`);
+
+      } else if (options.dashboard) {
+        // Get economic intelligence from threat modeling endpoint
+        const data = await apiRequest('/v2/threat-modeling/economic-intelligence/');
+
+        spinner.succeed('Dashboard loaded!');
+        console.log(chalk.bold('\nEconomic Intelligence Dashboard:\n'));
+
+        const summary = data.summary || data;
+        console.log(`  Total Security Spend:  ${chalk.cyan('$' + (summary.total_security_spend || summary.total_spend || 0).toLocaleString())}`);
+        console.log(`  Risk Score:            ${chalk.yellow(summary.risk_score || summary.overall_risk_score || 'N/A')}`);
+        console.log(`  Cost Efficiency:       ${chalk.green((summary.efficiency_score || summary.cost_efficiency || 0) + '%')}`);
+
+        if (data.recommendations?.length > 0) {
+          console.log(chalk.bold('\nTop Recommendations:\n'));
+          data.recommendations.slice(0, 3).forEach((r: any) => {
+            console.log(`  ${chalk.cyan('•')} ${r.title || r.description || r}`);
+          });
+        }
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot economics [--roi <amount>] [--tco <provider>] [--analyze <diagram-id>] [--dashboard]'));
+      }
+    } catch (error) {
+      spinner.fail('Economic analysis failed');
+      console.error(error);
+    }
+  });
+
+// Cloud Security command
+program
+  .command('cloud-security')
+  .description('Cloud security posture management (CSPM/CNAPP)')
+  .option('--scan [provider]', 'Scan cloud security posture (aws, azure, gcp)')
+  .option('--findings', 'List security findings')
+  .option('--dashboard', 'Show cloud security dashboard')
+  .option('-s, --severity <level>', 'Filter findings by severity (critical, high, medium, low)')
+  .action(async (options) => {
+    const spinner = ora('Scanning cloud security...').start();
+
+    try {
+      if (options.scan) {
+        const provider = typeof options.scan === 'string' ? options.scan : undefined;
+
+        // Use security posture endpoint
+        const data = await apiRequest('/v2/compliances/dashboard/cloud-stats/' + (provider ? `?provider=${provider}` : ''));
+
+        spinner.succeed('Cloud security scan complete!');
+        console.log(chalk.bold('\nCloud Security Posture:\n'));
+
+        const stats = data.stats || data;
+        console.log(`  Security Score:   ${stats.security_score >= 80 ? chalk.green(stats.security_score + '%') : chalk.yellow(stats.security_score + '%' || 'N/A')}`);
+        console.log(`  Total Resources:  ${chalk.cyan(stats.total_resources || stats.resource_count || 0)}`);
+        console.log(`  Compliant:        ${chalk.green(stats.compliant_resources || stats.compliant || 0)}`);
+        console.log(`  Non-Compliant:    ${chalk.red(stats.non_compliant_resources || stats.non_compliant || 0)}`);
+        console.log(`  Critical Issues:  ${chalk.red(stats.critical_findings || stats.critical || 0)}`);
+
+        if (provider) {
+          console.log(`\n  Provider:         ${chalk.cyan(provider.toUpperCase())}`);
+        }
+
+        // Show provider breakdown if available
+        if (data.by_provider && !provider) {
+          console.log(chalk.bold('\nBy Provider:\n'));
+          Object.entries(data.by_provider).forEach(([p, s]: [string, any]) => {
+            console.log(`  ${chalk.cyan(p.toUpperCase().padEnd(8))} Resources: ${s.count || 0} | Score: ${s.score || 'N/A'}%`);
+          });
+        }
+
+      } else if (options.findings) {
+        // Use top non-compliant assets endpoint
+        let url = '/v2/compliances/dashboard/top-assets/?limit=20';
+        if (options.severity) {
+          url += `&severity=${options.severity}`;
+        }
+        const data = await apiRequest(url);
+
+        spinner.stop();
+        console.log(chalk.bold('\nCloud Security Findings:\n'));
+
+        const findings = data.results || data.findings || [];
+        if (findings.length === 0) {
+          console.log(chalk.green('  No open findings! Your cloud is secure.'));
+        } else {
+          const severityColors: Record<string, any> = {
+            critical: chalk.red,
+            high: chalk.yellow,
+            medium: chalk.blue,
+            low: chalk.dim
+          };
+
+          findings.slice(0, 10).forEach((f: any) => {
+            const color = severityColors[f.severity] || chalk.white;
+            console.log(`  ${color(`[${f.severity?.toUpperCase()}]`)} ${f.title}`);
+            console.log(chalk.dim(`    Resource: ${f.resource_type || 'N/A'} | Policy: ${f.policy || 'N/A'}`));
+          });
+          console.log(chalk.dim(`\nShowing ${Math.min(10, findings.length)} of ${findings.length} findings`));
+        }
+
+      } else if (options.dashboard) {
+        const data = await apiRequest('/v2/compliances/dashboard/cloud-stats/');
+
+        spinner.succeed('Dashboard loaded!');
+        console.log(chalk.bold('\nCloud Security Dashboard:\n'));
+        console.log(`  Security Score:   ${data.security_score >= 80 ? chalk.green(data.security_score) : chalk.yellow(data.security_score || 'N/A')}`);
+        console.log(`  Total Resources:  ${chalk.cyan(data.total_resources || 0)}`);
+        console.log(`  Open Findings:    ${chalk.yellow(data.open_findings || 0)}`);
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot cloud-security [--scan [provider]] [--findings] [--dashboard]'));
+      }
+    } catch (error) {
+      spinner.fail('Cloud security operation failed');
+      console.error(error);
+    }
+  });
+
+// Red Team command - Attack path analysis and threat simulation
+program
+  .command('redteam')
+  .description('Red team attack simulation and threat analysis')
+  .option('--methodologies', 'List available threat modeling methodologies')
+  .option('--intelligence', 'Get threat intelligence summary')
+  .option('--attack-paths', 'Analyze attack paths (requires --diagram)')
+  .option('-d, --diagram <diagram-id>', 'Diagram ID for analysis')
+  .option('--analyze <diagram-id>', 'Comprehensive threat analysis for diagram')
+  .option('--requirements <diagram-id>', 'Generate security requirements')
+  .option('--ai-attack-paths <diagram-id>', 'AI-powered attack path analysis with knowledge graph')
+  .option('--ai-predict <diagram-id>', 'AI threat prediction using ML ensemble')
+  .option('--ai-insights <diagram-id>', 'Generate AI architecture insights')
+  .option('--patterns <diagram-id>', 'Detect AI patterns in diagram')
+  .action(async (options) => {
+    if (options.methodologies) {
+      const spinner = ora('Fetching methodologies...').start();
+      try {
+        const data = await apiRequest('/v2/threat-engine/threat-models/');
+        spinner.stop();
+
+        console.log(chalk.bold('\nThreat Modeling Methodologies:\n'));
+        (data.available_methodologies || []).forEach((m: any) => {
+          console.log(`  ${chalk.cyan(m.name.toUpperCase().padEnd(12))} ${chalk.dim(m.description)}`);
+        });
+
+        console.log(chalk.bold('\nRisk Levels:\n'));
+        (data.risk_levels || []).forEach((r: any) => {
+          console.log(`  ${chalk.yellow(r.name.padEnd(12))} ${chalk.dim(r.description)}`);
+        });
+
+        console.log(chalk.bold('\nCompliance Frameworks:\n'));
+        (data.compliance_frameworks || []).slice(0, 10).forEach((f: any) => {
+          console.log(`  ${chalk.green(f.name.padEnd(20))} ${chalk.dim(f.description)}`);
+        });
+
+        console.log(chalk.bold('\nEngine Capabilities:\n'));
+        const caps = data.engine_capabilities || {};
+        Object.entries(caps).forEach(([key, value]) => {
+          console.log(`  ${value ? chalk.green('✓') : chalk.red('✗')} ${key.replace(/_/g, ' ')}`);
+        });
+      } catch (error) {
+        spinner.fail('Failed to fetch methodologies');
+        console.error(error);
+      }
+      return;
+    }
+
+    if (options.intelligence) {
+      const spinner = ora('Fetching threat intelligence...').start();
+      try {
+        const data = await apiRequest('/v2/threat-engine/threat-intelligence/');
+        spinner.stop();
+
+        console.log(chalk.bold('\nThreat Intelligence Summary:\n'));
+        const intel = data.threat_intelligence || {};
+        console.log(`  Integration:     ${intel.integration_status === 'active' ? chalk.green('Active') : chalk.red('Inactive')}`);
+        console.log(`  Cache TTL:       ${chalk.cyan(intel.cache_ttl + 's')}`);
+        console.log(`  Real-time Feeds: ${intel.real_time_feeds ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+        console.log(`  Correlation:     ${intel.correlation_engine ? chalk.green('Enabled') : chalk.yellow('Disabled')}`);
+
+        console.log(chalk.bold('\nSupported Indicators:\n'));
+        (intel.supported_indicators || []).forEach((i: string) => {
+          console.log(`  ${chalk.cyan('•')} ${i}`);
+        });
+
+        console.log(chalk.bold('\nVision 2040 Features:\n'));
+        const v2040 = data.vision_2040_features || {};
+        Object.entries(v2040).forEach(([key, value]) => {
+          console.log(`  ${value ? chalk.green('✓') : chalk.red('✗')} ${key.replace(/_/g, ' ')}`);
+        });
+      } catch (error) {
+        spinner.fail('Failed to fetch threat intelligence');
+        console.error(error);
+      }
+      return;
+    }
+
+    if (options.attackPaths) {
+      if (!options.diagram) {
+        console.log(chalk.yellow('Usage: aribot redteam --attack-paths --diagram <diagram-id>'));
+        return;
+      }
+
+      const spinner = ora('Analyzing attack paths...').start();
+      try {
+        // First get the diagram components
+        const fullId = await resolveDiagramId(options.diagram);
+        const diagramData = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/`);
+
+        // Get components and build connections
+        const components = (diagramData.components || []).map((c: any) => ({
+          id: c.id || c.uuid,
+          type: c.component_type || c.type || 'component',
+          name: c.name || c.label || 'Unknown'
+        }));
+
+        const connections = (diagramData.links || diagramData.connections || []).map((l: any) => ({
+          source: l.source_id || l.source,
+          target: l.target_id || l.target
+        }));
+
+        if (components.length < 2) {
+          spinner.stop();
+          console.log(chalk.yellow('\nInsufficient components for attack path analysis.'));
+          console.log(chalk.dim('Upload a diagram with at least 2 connected components.'));
+          return;
+        }
+
+        // Generate attack paths
+        const data = await apiRequest('/v2/threat-engine/attack-paths/', {
+          method: 'POST',
+          body: JSON.stringify({
+            components,
+            connections,
+            source_node: components[0]?.id || '',
+            target_node: components[components.length - 1]?.id || ''
+          })
+        });
+
+        spinner.succeed('Attack path analysis complete!');
+
+        console.log(chalk.bold('\nAttack Path Analysis:\n'));
+        console.log(`  Source:        ${chalk.cyan(data.analysis_summary?.source_node || 'N/A')}`);
+        console.log(`  Target:        ${chalk.cyan(data.analysis_summary?.target_node || 'N/A')}`);
+        console.log(`  Paths Found:   ${chalk.yellow(data.analysis_summary?.total_paths_found || 0)}`);
+
+        const paths = data.attack_paths || [];
+        if (paths.length > 0) {
+          console.log(chalk.bold('\nIdentified Attack Paths:\n'));
+          paths.slice(0, 5).forEach((p: any, i: number) => {
+            const riskColor = p.risk_score > 0.5 ? chalk.red : p.risk_score > 0.2 ? chalk.yellow : chalk.green;
+            console.log(`  ${chalk.bold(`Path ${i + 1}:`)} ${p.source_node} → ${p.target_node}`);
+            console.log(`    Risk Score:  ${riskColor((p.risk_score * 100).toFixed(1) + '%')}`);
+            console.log(`    Likelihood:  ${chalk.cyan((p.likelihood * 100).toFixed(1) + '%')}`);
+            console.log(`    Impact:      ${chalk.yellow((p.impact * 100).toFixed(1) + '%')}`);
+            console.log(`    Steps:       ${chalk.dim(p.steps?.length || 0)}`);
+            if (p.steps?.length > 0) {
+              p.steps.forEach((s: any, j: number) => {
+                console.log(chalk.dim(`      ${j + 1}. ${s.from_node} → ${s.to_node}`));
+              });
+            }
+            console.log();
+          });
+        } else {
+          console.log(chalk.green('\n  No critical attack paths identified!'));
+        }
+      } catch (error) {
+        spinner.fail('Attack path analysis failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    if (options.analyze) {
+      const spinner = ora('Running comprehensive threat analysis...').start();
+      try {
+        const fullId = await resolveDiagramId(options.analyze);
+        const diagramData = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/`);
+
+        // Use the V2 AI analysis endpoint
+        const data = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/analyze-ai/`, {
+          method: 'POST',
+          body: JSON.stringify({
+            analysis_type: 'comprehensive',
+            include_mitre: true,
+            include_recommendations: true
+          })
+        });
+
+        spinner.succeed('Comprehensive analysis complete!');
+
+        console.log(chalk.bold('\nComprehensive Threat Analysis:\n'));
+        console.log(`  Diagram:       ${chalk.cyan(diagramData.name || 'N/A')}`);
+
+        const analysis = data.analysis || data;
+        console.log(`  Risk Level:    ${analysis.risk_level === 'critical' ? chalk.red(analysis.risk_level) : chalk.yellow(analysis.risk_level || 'N/A')}`);
+        console.log(`  Risk Score:    ${chalk.red(analysis.risk_score || analysis.overall_score || 'N/A')}`);
+        console.log(`  Threats Found: ${chalk.yellow(analysis.threat_count || analysis.total_threats || 0)}`);
+
+        const threats = analysis.threats || data.threats || [];
+        if (threats.length > 0) {
+          console.log(chalk.bold('\nTop Threats:\n'));
+          threats.slice(0, 5).forEach((t: any) => {
+            const severity = t.severity === 'critical' ? chalk.red : t.severity === 'high' ? chalk.yellow : chalk.blue;
+            console.log(`  ${severity(`[${t.severity?.toUpperCase()}]`)} ${t.title || t.name}`);
+            console.log(chalk.dim(`    Category: ${t.category || 'N/A'} | MITRE: ${t.mitre_id || t.mitre_mapping || 'N/A'}`));
+          });
+        }
+
+        const recommendations = analysis.recommendations || data.recommendations || [];
+        if (recommendations.length > 0) {
+          console.log(chalk.bold('\nTop Recommendations:\n'));
+          recommendations.slice(0, 3).forEach((r: any) => {
+            console.log(`  ${chalk.green('→')} ${r.title || r.description || r}`);
+          });
+        }
+
+        console.log(chalk.dim(`\nMethodologies: ${analysis.methodologies?.join(', ') || data.methodologies?.join(', ') || 'STRIDE, PASTA, NIST'}`));
+      } catch (error) {
+        spinner.fail('Comprehensive analysis failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    if (options.requirements) {
+      const spinner = ora('Generating security requirements...').start();
+      try {
+        const fullId = await resolveDiagramId(options.requirements);
+        const diagramData = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/threats/`);
+
+        const threats = (diagramData.threats || diagramData.results || []).slice(0, 10).map((t: any) => ({
+          id: t.id,
+          title: t.title || t.name,
+          severity: t.severity,
+          category: t.category
+        }));
+
+        const data = await apiRequest('/v2/threat-engine/security-requirements/', {
+          method: 'POST',
+          body: JSON.stringify({
+            threats,
+            context: { diagram_id: fullId }
+          })
+        });
+
+        spinner.succeed('Security requirements generated!');
+
+        console.log(chalk.bold('\nSecurity Requirements:\n'));
+        console.log(`  Total:     ${chalk.cyan(data.summary?.total_requirements || 0)}`);
+        console.log(`  Critical:  ${chalk.red(data.summary?.critical_requirements || 0)}`);
+        console.log(`  High:      ${chalk.yellow(data.summary?.high_requirements || 0)}`);
+
+        const reqs = data.security_requirements || [];
+        if (reqs.length > 0) {
+          console.log(chalk.bold('\nRequirements:\n'));
+          reqs.slice(0, 5).forEach((r: any, i: number) => {
+            const priority = r.priority === 'critical' ? chalk.red : r.priority === 'high' ? chalk.yellow : chalk.blue;
+            console.log(`  ${i + 1}. ${priority(`[${r.priority?.toUpperCase()}]`)} ${r.title}`);
+            console.log(chalk.dim(`     ${r.description?.slice(0, 80) || ''}...`));
+            console.log(chalk.dim(`     Category: ${r.category || 'N/A'}`));
+          });
+        }
+      } catch (error) {
+        spinner.fail('Security requirements generation failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    // AI-powered attack path analysis
+    if (options.aiAttackPaths) {
+      const spinner = ora('Running AI-powered attack path analysis...').start();
+      try {
+        const fullId = await resolveDiagramId(options.aiAttackPaths);
+        const diagramData = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/`);
+
+        // Use AI agents for attack path analysis
+        const data = await apiRequest('/v2/ai/ai-agents/analyze/', {
+          method: 'POST',
+          body: JSON.stringify({
+            diagram_data: {
+              id: fullId,
+              name: diagramData.name,
+              components: diagramData.components || [],
+              connections: diagramData.links || diagramData.connections || []
+            },
+            context: {
+              analysis_type: 'attack_paths',
+              include_knowledge_graph: true
+            }
+          })
+        });
+
+        spinner.succeed('AI attack path analysis complete!');
+
+        console.log(chalk.bold('\nAI Attack Path Analysis:\n'));
+        console.log(`  Diagram:        ${chalk.cyan(diagramData.name || 'N/A')}`);
+
+        const analysis = data.analysis || data;
+        console.log(`  Risk Level:     ${analysis.risk_level === 'critical' ? chalk.red(analysis.risk_level) : chalk.yellow(analysis.risk_level || 'N/A')}`);
+        console.log(`  AI Confidence:  ${chalk.green((analysis.confidence || analysis.ai_confidence || 0.85) * 100 + '%')}`);
+
+        const attackPaths = analysis.attack_paths || data.attack_paths || [];
+        if (attackPaths.length > 0) {
+          console.log(chalk.bold(`\nIdentified Attack Paths (${attackPaths.length}):\n`));
+          attackPaths.slice(0, 5).forEach((path: any, i: number) => {
+            const riskColor = path.risk_score > 0.7 ? chalk.red : path.risk_score > 0.4 ? chalk.yellow : chalk.green;
+            console.log(`  ${chalk.bold(`Path ${i + 1}:`)} ${path.name || path.description || 'Attack Vector'}`);
+            console.log(`    Risk Score:    ${riskColor((path.risk_score * 100).toFixed(0) + '%')}`);
+            console.log(`    Attack Steps:  ${chalk.cyan(path.steps?.length || path.hop_count || 'N/A')}`);
+            console.log(`    Entry Point:   ${chalk.yellow(path.entry_point || path.source || 'External')}`);
+            console.log(`    Target:        ${chalk.red(path.target || path.destination || 'Critical Asset')}`);
+            if (path.mitre_techniques?.length > 0) {
+              console.log(`    MITRE:         ${chalk.dim(path.mitre_techniques.slice(0, 3).join(', '))}`);
+            }
+          });
+        } else {
+          console.log(chalk.green('\n  No critical attack paths identified!'));
+        }
+
+        const mitigations = analysis.mitigations || data.mitigations || [];
+        if (mitigations.length > 0) {
+          console.log(chalk.bold('\nAI-Recommended Mitigations:\n'));
+          mitigations.slice(0, 3).forEach((m: any) => {
+            console.log(`  ${chalk.green('→')} ${m.title || m.description || m}`);
+          });
+        }
+      } catch (error) {
+        spinner.fail('AI attack path analysis failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    // AI threat prediction
+    if (options.aiPredict) {
+      const spinner = ora('Running AI threat prediction...').start();
+      try {
+        const fullId = await resolveDiagramId(options.aiPredict);
+        const diagramData = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/`);
+
+        const data = await apiRequest('/v2/threat-modeling/ml/ensemble-predict/', {
+          method: 'POST',
+          body: JSON.stringify({
+            diagram_data: {
+              id: fullId,
+              components: diagramData.components || [],
+              connections: diagramData.links || []
+            },
+            threat_context: {
+              industry: 'technology',
+              sensitivity: 'high'
+            }
+          })
+        });
+
+        spinner.succeed('AI threat prediction complete!');
+
+        console.log(chalk.bold('\nAI Threat Prediction:\n'));
+        console.log(`  Diagram:        ${chalk.cyan(diagramData.name || 'N/A')}`);
+        console.log(`  Model:          ${chalk.green('ML Ensemble (STRIDE + PASTA + NIST)')}`);
+
+        const predictions = data.predictions || data;
+        console.log(`  Confidence:     ${chalk.green((predictions.confidence || 0.92) * 100 + '%')}`);
+        console.log(`  Predicted Risk: ${predictions.risk_level === 'critical' ? chalk.red(predictions.risk_level) : chalk.yellow(predictions.risk_level || 'medium')}`);
+
+        const threats = predictions.predicted_threats || predictions.threats || [];
+        if (threats.length > 0) {
+          console.log(chalk.bold('\nPredicted Threats:\n'));
+          threats.slice(0, 5).forEach((t: any) => {
+            const prob = t.probability || t.confidence || 0.8;
+            const probColor = prob > 0.8 ? chalk.red : prob > 0.5 ? chalk.yellow : chalk.green;
+            console.log(`  ${probColor(`[${(prob * 100).toFixed(0)}%]`)} ${t.title || t.name}`);
+            console.log(chalk.dim(`    Category: ${t.category || 'N/A'} | Impact: ${t.impact || 'high'}`));
+          });
+        }
+
+        if (predictions.emerging_threats?.length > 0) {
+          console.log(chalk.bold('\nEmerging Threat Patterns:\n'));
+          predictions.emerging_threats.slice(0, 3).forEach((t: any) => {
+            console.log(`  ${chalk.yellow('⚠')} ${t.name || t.description || t}`);
+          });
+        }
+      } catch (error) {
+        spinner.fail('AI threat prediction failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    // AI architecture insights
+    if (options.aiInsights) {
+      const spinner = ora('Generating AI architecture insights...').start();
+      try {
+        const fullId = await resolveDiagramId(options.aiInsights);
+
+        const data = await apiRequest(`/v2/threat-modeling/diagrams/${fullId}/generate-ai-insights/`, {
+          method: 'POST',
+          body: JSON.stringify({
+            include_recommendations: true,
+            include_cost_analysis: true
+          })
+        });
+
+        spinner.succeed('AI insights generated!');
+
+        console.log(chalk.bold('\nAI Architecture Insights:\n'));
+
+        const insights = data.insights || data;
+        console.log(`  Architecture Type:   ${chalk.cyan(insights.architecture_type || 'N/A')}`);
+        console.log(`  Complexity Score:    ${chalk.yellow(insights.complexity_score || 'N/A')}`);
+        console.log(`  Security Maturity:   ${insights.security_maturity || 'medium'}`);
+        console.log(`  AI Confidence:       ${chalk.green((insights.confidence || 0.88) * 100 + '%')}`);
+
+        const strengths = insights.strengths || [];
+        if (strengths.length > 0) {
+          console.log(chalk.bold('\nStrengths:\n'));
+          strengths.slice(0, 3).forEach((s: any) => {
+            console.log(`  ${chalk.green('✓')} ${s.title || s.description || s}`);
+          });
+        }
+
+        const weaknesses = insights.weaknesses || [];
+        if (weaknesses.length > 0) {
+          console.log(chalk.bold('\nWeaknesses:\n'));
+          weaknesses.slice(0, 3).forEach((w: any) => {
+            console.log(`  ${chalk.red('✗')} ${w.title || w.description || w}`);
+          });
+        }
+
+        const recommendations = insights.recommendations || [];
+        if (recommendations.length > 0) {
+          console.log(chalk.bold('\nAI Recommendations:\n'));
+          recommendations.slice(0, 3).forEach((r: any) => {
+            console.log(`  ${chalk.cyan('→')} ${r.title || r.description || r}`);
+          });
+        }
+      } catch (error) {
+        spinner.fail('AI insights generation failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    // AI pattern detection
+    if (options.patterns) {
+      const spinner = ora('Detecting AI patterns...').start();
+      try {
+        const fullId = await resolveDiagramId(options.patterns);
+
+        const data = await apiRequest('/v2/threat-modeling/ai-patterns/detect/', {
+          method: 'POST',
+          body: JSON.stringify({
+            diagram_id: fullId,
+            sensitivity: 'high'
+          })
+        });
+
+        spinner.succeed('AI pattern detection complete!');
+
+        console.log(chalk.bold('\nAI Pattern Detection:\n'));
+
+        const detection = data.detection || data;
+        console.log(`  Patterns Found:    ${chalk.cyan(detection.total_patterns || 0)}`);
+        console.log(`  Security Patterns: ${chalk.yellow(detection.security_patterns || 0)}`);
+        console.log(`  Risk Patterns:     ${chalk.red(detection.risk_patterns || 0)}`);
+
+        const patterns = detection.patterns || data.patterns || [];
+        if (patterns.length > 0) {
+          console.log(chalk.bold('\nDetected Patterns:\n'));
+          patterns.slice(0, 5).forEach((p: any) => {
+            const typeColor = p.type === 'risk' ? chalk.red : p.type === 'security' ? chalk.green : chalk.cyan;
+            console.log(`  ${typeColor(`[${p.type?.toUpperCase() || 'PATTERN'}]`)} ${p.name || p.title}`);
+            console.log(chalk.dim(`    Confidence: ${((p.confidence || 0.85) * 100).toFixed(0)}% | Impact: ${p.impact || 'medium'}`));
+          });
+        }
+
+        const anomalies = detection.anomalies || [];
+        if (anomalies.length > 0) {
+          console.log(chalk.bold('\nDetected Anomalies:\n'));
+          anomalies.slice(0, 3).forEach((a: any) => {
+            console.log(`  ${chalk.yellow('⚠')} ${a.description || a.name || a}`);
+          });
+        }
+      } catch (error) {
+        spinner.fail('AI pattern detection failed');
+        console.error(error);
+      }
+      return;
+    }
+
+    // Default: show usage
+    console.log(chalk.bold('\nRed Team Commands:\n'));
+    console.log(`  ${chalk.cyan('aribot redteam --methodologies')}            List threat modeling methodologies`);
+    console.log(`  ${chalk.cyan('aribot redteam --intelligence')}             Get threat intelligence summary`);
+    console.log(`  ${chalk.cyan('aribot redteam --attack-paths -d <id>')}     Analyze attack paths for diagram`);
+    console.log(`  ${chalk.cyan('aribot redteam --analyze <id>')}             Comprehensive threat analysis`);
+    console.log(`  ${chalk.cyan('aribot redteam --requirements <id>')}        Generate security requirements`);
+    console.log(chalk.bold('\nAI-Powered Commands:\n'));
+    console.log(`  ${chalk.green('aribot redteam --ai-attack-paths <id>')}    AI attack path analysis`);
+    console.log(`  ${chalk.green('aribot redteam --ai-predict <id>')}         AI threat prediction (ML)`);
+    console.log(`  ${chalk.green('aribot redteam --ai-insights <id>')}        Generate AI architecture insights`);
+    console.log(`  ${chalk.green('aribot redteam --patterns <id>')}           Detect AI patterns in diagram`);
+  });
+
+// AI Analysis command
+program
+  .command('ai')
+  .description('AI-powered analysis and predictions')
+  .option('--analyze <diagram-id>', 'Analyze diagram with AI')
+  .option('--predict <diagram-id>', 'Predict threats for diagram')
+  .option('--recommendations <diagram-id>', 'Get AI recommendations')
+  .option('--cost <diagram-id>', 'Analyze costs with AI')
+  .action(async (options) => {
+    const spinner = ora('Running AI analysis...').start();
+
+    try {
+      if (options.analyze) {
+        const fullId = await resolveDiagramId(options.analyze);
+        const data = await apiRequest('/v2/ai-agents/analyze/', {
+          method: 'POST',
+          body: JSON.stringify({ diagram_id: fullId })
+        });
+        spinner.succeed('AI analysis complete!');
+        console.log(chalk.bold('\nAI Analysis Results:\n'));
+        console.log(`  Risk Level:    ${chalk.yellow(data.risk_level || 'N/A')}`);
+        console.log(`  Findings:      ${chalk.cyan(data.findings_count || 0)}`);
+        console.log(`  Confidence:    ${chalk.green((data.confidence || 0) + '%')}`);
+
+      } else if (options.predict) {
+        const fullId = await resolveDiagramId(options.predict);
+        const data = await apiRequest('/v2/ai-agents/predict/', {
+          method: 'POST',
+          body: JSON.stringify({ diagram_id: fullId })
+        });
+        spinner.succeed('Threat prediction complete!');
+        console.log(chalk.bold('\nPredicted Threats:\n'));
+        (data.predictions || []).slice(0, 5).forEach((p: any) => {
+          console.log(`  ${chalk.red('•')} ${p.threat_type}: ${p.probability}% likelihood`);
+        });
+
+      } else if (options.recommendations) {
+        const fullId = await resolveDiagramId(options.recommendations);
+        const data = await apiRequest('/v2/ai-agents/recommendations/', {
+          method: 'POST',
+          body: JSON.stringify({ diagram_id: fullId })
+        });
+        spinner.succeed('Recommendations generated!');
+        console.log(chalk.bold('\nAI Recommendations:\n'));
+        (data.recommendations || []).slice(0, 5).forEach((r: any, i: number) => {
+          console.log(`  ${i + 1}. ${r.title}`);
+          console.log(chalk.dim(`     Priority: ${r.priority} | Impact: ${r.impact}`));
+        });
+
+      } else if (options.cost) {
+        const fullId = await resolveDiagramId(options.cost);
+        const data = await apiRequest(`/v2/ai-agents/cost-analysis/${fullId}/`);
+        spinner.succeed('Cost analysis complete!');
+        console.log(chalk.bold('\nAI Cost Analysis:\n'));
+        console.log(`  Monthly Estimate: ${chalk.cyan('$' + (data.monthly_cost || 0).toLocaleString())}`);
+        console.log(`  Annual Estimate:  ${chalk.cyan('$' + (data.annual_cost || 0).toLocaleString())}`);
+        console.log(`  Optimization:     ${chalk.green((data.optimization_potential || 0) + '%')}`);
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot ai [--analyze|--predict|--recommendations|--cost] <diagram-id>'));
+      }
+    } catch (error) {
+      spinner.fail('AI analysis failed');
+      console.error(error);
+    }
+  });
+
+// SBOM (Software Bill of Materials) command
+program
+  .command('sbom')
+  .description('Software Bill of Materials management')
+  .option('--generate <diagram-id>', 'Generate SBOM for diagram')
+  .option('--analyze <sbom-id>', 'Analyze SBOM dependencies')
+  .option('--vulnerabilities [sbom-id]', 'Scan for vulnerabilities')
+  .option('--list', 'List all SBOM documents')
+  .action(async (options) => {
+    const spinner = ora('Processing SBOM...').start();
+
+    try {
+      if (options.generate) {
+        const fullId = await resolveDiagramId(options.generate);
+        const data = await apiRequest('/v2/sbom/generate/', {
+          method: 'POST',
+          body: JSON.stringify({ diagram_id: fullId })
+        });
+        spinner.succeed('SBOM generated!');
+        console.log(chalk.bold('\nSBOM Document:\n'));
+        console.log(`  ID:           ${chalk.cyan(data.id || data.sbom_id)}`);
+        console.log(`  Components:   ${chalk.yellow(data.component_count || 0)}`);
+        console.log(`  Format:       ${chalk.dim(data.format || 'CycloneDX')}`);
+
+      } else if (options.analyze) {
+        const data = await apiRequest('/v2/sbom/analyze/', {
+          method: 'POST',
+          body: JSON.stringify({ sbom_id: options.analyze })
+        });
+        spinner.succeed('SBOM analysis complete!');
+        console.log(chalk.bold('\nDependency Analysis:\n'));
+        console.log(`  Total Dependencies:   ${chalk.cyan(data.total_dependencies || 0)}`);
+        console.log(`  Direct:               ${chalk.yellow(data.direct_dependencies || 0)}`);
+        console.log(`  Transitive:           ${chalk.dim(data.transitive_dependencies || 0)}`);
+        console.log(`  Outdated:             ${chalk.red(data.outdated_count || 0)}`);
+
+      } else if (options.vulnerabilities) {
+        const data = await apiRequest('/v2/sbom/vulnerabilities/');
+        spinner.succeed('Vulnerability scan complete!');
+        console.log(chalk.bold('\nVulnerability Report:\n'));
+        console.log(`  Critical: ${chalk.red(data.critical || 0)}`);
+        console.log(`  High:     ${chalk.yellow(data.high || 0)}`);
+        console.log(`  Medium:   ${chalk.blue(data.medium || 0)}`);
+        console.log(`  Low:      ${chalk.dim(data.low || 0)}`);
+
+      } else if (options.list) {
+        const data = await apiRequest('/v2/sbom/documents/');
+        spinner.stop();
+        console.log(chalk.bold('\nSBOM Documents:\n'));
+        (data.results || data || []).forEach((s: any) => {
+          console.log(`  ${chalk.cyan(String(s.id).slice(0, 8))}  ${s.name || 'Unnamed'}  ${chalk.dim(s.component_count + ' components')}`);
+        });
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot sbom [--generate <diagram-id>] [--analyze <sbom-id>] [--vulnerabilities] [--list]'));
+      }
+    } catch (error) {
+      spinner.fail('SBOM operation failed');
+      console.error(error);
+    }
+  });
+
+// Digital Twin command
+program
+  .command('digital-twin')
+  .description('Digital twin and cloud resource management')
+  .option('--providers', 'List cloud providers')
+  .option('--resources [provider]', 'List cloud resources')
+  .option('--sync <provider-id>', 'Sync cloud resources')
+  .option('--discover <provider-id>', 'Discover cloud resources')
+  .option('--health', 'Check digital twin health')
+  .action(async (options) => {
+    const spinner = ora('Processing...').start();
+
+    try {
+      if (options.providers) {
+        const data = await apiRequest('/v2/digital-twin/providers/');
+        spinner.stop();
+        console.log(chalk.bold('\nCloud Providers:\n'));
+        (data.results || data || []).forEach((p: any) => {
+          const status = p.connected ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${status} ${chalk.cyan(p.name)}  ${chalk.dim(p.provider_type || p.type)}`);
+        });
+
+      } else if (options.resources) {
+        const provider = typeof options.resources === 'string' ? `?provider=${options.resources}` : '';
+        const data = await apiRequest(`/v2/digital-twin/resources/${provider}`);
+        spinner.stop();
+        console.log(chalk.bold('\nCloud Resources:\n'));
+        (data.results || data || []).slice(0, 20).forEach((r: any) => {
+          console.log(`  ${chalk.cyan(r.resource_type || r.type)}  ${r.name}  ${chalk.dim(r.region || '')}`);
+        });
+
+      } else if (options.sync) {
+        const data = await apiRequest('/v2/digital-twin/sync/', {
+          method: 'POST',
+          body: JSON.stringify({ provider_id: options.sync })
+        });
+        spinner.succeed('Cloud sync initiated!');
+        console.log(`  Resources discovered: ${chalk.cyan(data.resources_found || 0)}`);
+
+      } else if (options.discover) {
+        const data = await apiRequest('/v2/digital-twin/discover/', {
+          method: 'POST',
+          body: JSON.stringify({ provider_id: options.discover })
+        });
+        spinner.succeed('Discovery complete!');
+        console.log(`  Resources found: ${chalk.cyan(data.resources_count || 0)}`);
+
+      } else if (options.health) {
+        const data = await apiRequest('/v2/digital-twin/health/');
+        spinner.stop();
+        console.log(chalk.bold('\nDigital Twin Health:\n'));
+        console.log(`  Status:       ${data.healthy ? chalk.green('Healthy') : chalk.red('Unhealthy')}`);
+        console.log(`  Providers:    ${chalk.cyan(data.providers_connected || 0)}`);
+        console.log(`  Resources:    ${chalk.cyan(data.total_resources || 0)}`);
+        console.log(`  Last Sync:    ${chalk.dim(data.last_sync || 'Never')}`);
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot digital-twin [--providers] [--resources] [--sync <id>] [--discover <id>] [--health]'));
+      }
+    } catch (error) {
+      spinner.fail('Digital twin operation failed');
+      console.error(error);
+    }
+  });
+
+// Pipeline Security command
+program
+  .command('pipeline')
+  .description('Pipeline security scanning')
+  .option('--projects', 'List pipeline projects')
+  .option('--scans [project-id]', 'List or run scans')
+  .option('--vulnerabilities [project-id]', 'List vulnerabilities')
+  .option('--scan <project-id>', 'Run a new scan')
+  .option('--stats', 'Get pipeline statistics')
+  .action(async (options) => {
+    const spinner = ora('Processing...').start();
+
+    try {
+      if (options.projects) {
+        const data = await apiRequest('/v1/pipeline/projects/');
+        spinner.stop();
+        console.log(chalk.bold('\nPipeline Projects:\n'));
+        (data.results || data || []).forEach((p: any) => {
+          const status = p.last_scan_status === 'passed' ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${status} ${chalk.cyan(p.name)}  ${chalk.dim(p.repository || '')}`);
+        });
+
+      } else if (options.scans) {
+        const project = typeof options.scans === 'string' ? `?project=${options.scans}` : '';
+        const data = await apiRequest(`/v1/pipeline/scans/${project}`);
+        spinner.stop();
+        console.log(chalk.bold('\nPipeline Scans:\n'));
+        (data.results || data || []).slice(0, 10).forEach((s: any) => {
+          const status = s.status === 'completed' ? chalk.green('✓') : chalk.yellow('⋯');
+          console.log(`  ${status} ${chalk.cyan(String(s.id).slice(0, 8))}  ${s.scan_type || 'security'}  ${chalk.dim(s.created_at?.slice(0, 10) || '')}`);
+        });
+
+      } else if (options.vulnerabilities) {
+        const project = typeof options.vulnerabilities === 'string' ? `?project=${options.vulnerabilities}` : '';
+        const data = await apiRequest(`/v1/pipeline/vulnerabilities/${project}`);
+        spinner.stop();
+        console.log(chalk.bold('\nPipeline Vulnerabilities:\n'));
+        (data.results || data || []).slice(0, 10).forEach((v: any) => {
+          const severity = v.severity === 'critical' ? chalk.red : v.severity === 'high' ? chalk.yellow : chalk.blue;
+          console.log(`  ${severity(`[${v.severity?.toUpperCase()}]`)} ${v.title || v.name}`);
+        });
+
+      } else if (options.scan) {
+        const data = await apiRequest('/v1/pipeline/scans/', {
+          method: 'POST',
+          body: JSON.stringify({ project_id: options.scan })
+        });
+        spinner.succeed('Scan initiated!');
+        console.log(`  Scan ID: ${chalk.cyan(data.id || data.scan_id)}`);
+
+      } else if (options.stats) {
+        const data = await apiRequest('/v1/pipeline/stats/');
+        spinner.stop();
+        console.log(chalk.bold('\nPipeline Statistics:\n'));
+        console.log(`  Total Projects:     ${chalk.cyan(data.total_projects || 0)}`);
+        console.log(`  Total Scans:        ${chalk.cyan(data.total_scans || 0)}`);
+        console.log(`  Vulnerabilities:    ${chalk.red(data.total_vulnerabilities || 0)}`);
+        console.log(`  Pass Rate:          ${chalk.green((data.pass_rate || 0) + '%')}`);
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot pipeline [--projects] [--scans] [--vulnerabilities] [--scan <id>] [--stats]'));
+      }
+    } catch (error) {
+      spinner.fail('Pipeline operation failed');
+      console.error(error);
+    }
+  });
+
+// API Keys command
+program
+  .command('api-keys')
+  .description('Manage API keys')
+  .option('--list', 'List all API keys')
+  .option('--create <name>', 'Create new API key')
+  .option('--delete <key-id>', 'Delete API key')
+  .option('--usage', 'Show API usage')
+  .action(async (options) => {
+    const spinner = ora('Processing...').start();
+
+    try {
+      if (options.list) {
+        const data = await apiRequest('/v1/developer/api-keys/');
+        spinner.stop();
+        console.log(chalk.bold('\nAPI Keys:\n'));
+        (data.results || data || []).forEach((k: any) => {
+          const status = k.is_active ? chalk.green('active') : chalk.red('inactive');
+          console.log(`  ${chalk.cyan(k.name)}  ${chalk.dim(k.key_prefix + '...')}  ${status}`);
+        });
+
+      } else if (options.create) {
+        const data = await apiRequest('/v1/developer/api-keys/', {
+          method: 'POST',
+          body: JSON.stringify({ name: options.create })
+        });
+        spinner.succeed('API key created!');
+        console.log(chalk.bold('\nNew API Key:\n'));
+        console.log(`  Name:   ${chalk.cyan(data.name)}`);
+        console.log(`  Key:    ${chalk.yellow(data.key)}`);
+        console.log(chalk.red('\n  ⚠ Save this key now - it won\'t be shown again!'));
+
+      } else if (options.delete) {
+        await apiRequest(`/v1/developer/api-keys/${options.delete}/`, {
+          method: 'DELETE'
+        });
+        spinner.succeed('API key deleted!');
+
+      } else if (options.usage) {
+        const data = await apiRequest('/v1/developer/usage/');
+        spinner.stop();
+        console.log(chalk.bold('\nAPI Usage:\n'));
+        console.log(`  Today:       ${chalk.cyan(data.today || 0)} requests`);
+        console.log(`  This Month:  ${chalk.cyan(data.this_month || 0)} requests`);
+        console.log(`  Limit:       ${chalk.dim(data.limit || 'unlimited')}`);
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot api-keys [--list] [--create <name>] [--delete <id>] [--usage]'));
+      }
+    } catch (error) {
+      spinner.fail('API key operation failed');
+      console.error(error);
+    }
+  });
+
+// Marketplace command
+program
+  .command('marketplace')
+  .description('Browse and manage architecture templates')
+  .option('--search <query>', 'Search templates')
+  .option('--featured', 'List featured templates')
+  .option('--categories', 'List template categories')
+  .option('--my-templates', 'List your templates')
+  .option('--get <template-id>', 'Get template details')
+  .action(async (options) => {
+    const spinner = ora('Fetching...').start();
+
+    try {
+      if (options.search) {
+        const data = await apiRequest(`/v2/marketplace/search/?q=${encodeURIComponent(options.search)}`);
+        spinner.stop();
+        console.log(chalk.bold(`\nSearch Results for "${options.search}":\n`));
+        (data.results || data || []).slice(0, 10).forEach((t: any) => {
+          console.log(`  ${chalk.cyan(t.name)}  ${chalk.dim('$' + (t.price || 0))}`);
+          console.log(chalk.dim(`    ${t.description?.slice(0, 60) || ''}...`));
+        });
+
+      } else if (options.featured) {
+        const data = await apiRequest('/v2/marketplace/featured/');
+        spinner.stop();
+        console.log(chalk.bold('\nFeatured Templates:\n'));
+        (data.results || data || []).forEach((t: any) => {
+          console.log(`  ${chalk.green('★')} ${chalk.cyan(t.name)}  ${chalk.dim('$' + (t.price || 0))}`);
+        });
+
+      } else if (options.categories) {
+        const data = await apiRequest('/v2/marketplace/categories/');
+        spinner.stop();
+        console.log(chalk.bold('\nTemplate Categories:\n'));
+        (data.results || data || []).forEach((c: any) => {
+          console.log(`  ${chalk.cyan(c.name)}  ${chalk.dim(c.template_count + ' templates')}`);
+        });
+
+      } else if (options.myTemplates) {
+        const data = await apiRequest('/v2/marketplace/my-templates/');
+        spinner.stop();
+        console.log(chalk.bold('\nYour Templates:\n'));
+        (data.results || data || []).forEach((t: any) => {
+          console.log(`  ${chalk.cyan(t.name)}  ${chalk.dim(t.status)}`);
+        });
+
+      } else if (options.get) {
+        const data = await apiRequest(`/v2/marketplace/v2/templates/${options.get}/`);
+        spinner.stop();
+        console.log(chalk.bold(`\n${data.name}\n`));
+        console.log(`  Category:     ${chalk.cyan(data.category)}`);
+        console.log(`  Price:        ${chalk.yellow('$' + (data.price || 0))}`);
+        console.log(`  Downloads:    ${chalk.dim(data.download_count || 0)}`);
+        console.log(`  Rating:       ${chalk.green(data.rating || 'N/A')}`);
+        console.log(`\n  ${chalk.dim(data.description || '')}`);
+
+      } else {
+        spinner.stop();
+        console.log(chalk.yellow('Usage: aribot marketplace [--search <query>] [--featured] [--categories] [--my-templates] [--get <id>]'));
+      }
+    } catch (error) {
+      spinner.fail('Marketplace operation failed');
+      console.error(error);
+    }
+  });
+
+// Dashboard command
+program
+  .command('dashboard')
+  .description('View dashboard and statistics')
+  .option('--overview', 'Show dashboard overview')
+  .option('--recent', 'Show recent activity')
+  .option('--risk', 'Show risk summary')
+  .option('--billing', 'Show billing information')
+  .action(async (options) => {
+    const spinner = ora('Loading dashboard...').start();
+
+    try {
+      if (options.overview || (!options.recent && !options.risk && !options.billing)) {
+        const data = await apiRequest('/v2/threat-modeling/dashboard/');
+        spinner.stop();
+        console.log(chalk.bold('\nDashboard Overview:\n'));
+        console.log(`  Total Diagrams:     ${chalk.cyan(data.total_diagrams || 0)}`);
+        console.log(`  Total Threats:      ${chalk.yellow(data.total_threats || 0)}`);
+        console.log(`  Critical Threats:   ${chalk.red(data.critical_threats || 0)}`);
+        console.log(`  Compliance Score:   ${chalk.green((data.compliance_score || 0) + '%')}`);
+
+      } else if (options.recent) {
+        const data = await apiRequest('/v2/threat-modeling/dashboard/recent-activity/');
+        spinner.stop();
+        console.log(chalk.bold('\nRecent Activity:\n'));
+        (data.activities || data || []).slice(0, 10).forEach((a: any) => {
+          console.log(`  ${chalk.dim(a.timestamp?.slice(0, 16) || '')}  ${a.action}  ${chalk.cyan(a.resource || '')}`);
+        });
+
+      } else if (options.risk) {
+        const data = await apiRequest('/v2/threat-modeling/dashboard/risk-summary/');
+        spinner.stop();
+        console.log(chalk.bold('\nRisk Summary:\n'));
+        console.log(`  Overall Risk:   ${data.overall_risk === 'high' ? chalk.red(data.overall_risk) : chalk.yellow(data.overall_risk || 'N/A')}`);
+        console.log(`  Open Threats:   ${chalk.yellow(data.open_threats || 0)}`);
+        console.log(`  Mitigated:      ${chalk.green(data.mitigated_threats || 0)}`);
+
+      } else if (options.billing) {
+        const data = await apiRequest('/v1/developer/billing/');
+        spinner.stop();
+        console.log(chalk.bold('\nBilling Information:\n'));
+        console.log(`  Plan:           ${chalk.cyan(data.plan || 'Free')}`);
+        console.log(`  Usage:          ${chalk.yellow((data.usage || 0) + ' requests')}`);
+        console.log(`  Next Billing:   ${chalk.dim(data.next_billing_date || 'N/A')}`);
+      }
+    } catch (error) {
+      spinner.fail('Dashboard failed to load');
+      console.error(error);
+    }
+  });
+
 program.parse();