@peakinfer/cli 1.0.133

package/src/commands/demo.ts

@@ -0,0 +1,175 @@
+/**
+ * PeakInfer Demo Command
+ *
+ * Runs a pre-computed demo analysis WITHOUT requiring an API key.
+ * This is the first-contact moment - must work offline.
+ *
+ * Per Design Doc v1.9.3:
+ * - Shows the "Magic Moment" (drift detection)
+ * - Works without API key
+ * - Completes in under 30 seconds
+ * - Always produces an alarming finding
+ */
+import { Command } from 'commander';
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+
+// Get package root directory
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageRoot = join(__dirname, '..', '..');
+
+const COLORS = {
+  text: '#c9d1d9',
+  command: '#f0f6fc',
+  info: '#8b949e',
+  path: '#a5a29e',
+  critical: '#991b1b',
+  criticalLight: '#b91c1c',
+  warning: '#d29922',
+  duration: '#9e6a03',
+  border: '#30363d',
+  success: '#2d6a4f',
+};
+
+interface DemoData {
+  version: string;
+  drift: {
+    detected: boolean;
+    type: string;
+    description: string;
+    evidence: {
+      code: string;
+      runtime: string;
+      impact: string;
+      duration: string;
+    };
+  };
+  issues: Array<{
+    id: string;
+    severity: string;
+    category: string;
+    title: string;
+    description: string;
+    impact: string;
+    savings?: string;
+    file: string;
+    line: number;
+    fix: {
+      description: string;
+      effort: string;
+    };
+  }>;
+  summary: {
+    totalInferencePoints: number;
+    providers: string[];
+    criticalIssues: number;
+    highIssues: number;
+    mediumIssues: number;
+    estimatedMonthlySavings: string;
+    estimatedLatencyImprovement: string;
+  };
+}
+
+export function registerDemoCommand(program: Command): void {
+  program
+    .command('demo')
+    .description('see PeakInfer in action with a sample project (no API key needed)')
+    .option('--verbose', 'show additional details')
+    .action(async (options: { verbose?: boolean }) => {
+      await runDemo(options.verbose);
+    });
+}
+
+async function runDemo(verbose?: boolean): Promise<void> {
+  const startTime = Date.now();
+
+  // Load pre-computed demo data
+  const demoDataPath = join(packageRoot, 'fixtures', 'demo', 'precomputed.json');
+
+  if (!existsSync(demoDataPath)) {
+    console.error(chalk.hex(COLORS.critical)('Error: Demo data not found. Please reinstall PeakInfer.'));
+    process.exit(1);
+  }
+
+  const demoData: DemoData = JSON.parse(readFileSync(demoDataPath, 'utf-8'));
+
+  // Render the demo output
+  console.log();
+  console.log(chalk.hex(COLORS.border)('╔══════════════════════════════════════════════════════════════╗'));
+  console.log(chalk.hex(COLORS.border)('║') + chalk.hex(COLORS.text)('              PeakInfer Demo                                  ') + chalk.hex(COLORS.border)('║'));
+  console.log(chalk.hex(COLORS.border)('╚══════════════════════════════════════════════════════════════╝'));
+  console.log();
+
+  // Simulate scanning animation
+  console.log(chalk.hex(COLORS.info)('Scanning demo project...'));
+  await sleep(500);
+  console.log(chalk.hex(COLORS.info)(`Found ${demoData.summary.totalInferencePoints} inference points`));
+  await sleep(300);
+  console.log();
+
+  // THE MAGIC MOMENT - Drift Detection
+  if (demoData.drift.detected) {
+    console.log(chalk.hex(COLORS.criticalLight)('DRIFT DETECTED'));
+    console.log();
+    console.log(chalk.hex(COLORS.border)('  ┌─────────────────────────────────────────────────────────┐'));
+    console.log(chalk.hex(COLORS.border)('  │') + chalk.hex(COLORS.info)(' YOUR CODE:    ') + chalk.hex(COLORS.text)(`${demoData.drift.evidence.code}`) + '                              ' + chalk.hex(COLORS.border)('│'));
+    console.log(chalk.hex(COLORS.border)('  │') + chalk.hex(COLORS.info)(' RUNTIME:      ') + chalk.hex(COLORS.critical)(`${demoData.drift.evidence.runtime}`) + '          ' + chalk.hex(COLORS.border)('│'));
+    console.log(chalk.hex(COLORS.border)('  │') + chalk.hex(COLORS.info)(' IMPACT:       ') + chalk.hex(COLORS.warning)(`${demoData.drift.evidence.impact}`) + '         ' + chalk.hex(COLORS.border)('│'));
+    console.log(chalk.hex(COLORS.border)('  │') + chalk.hex(COLORS.info)(' BROKEN FOR:   ') + chalk.hex(COLORS.duration)(`${demoData.drift.evidence.duration}`) + '                                    ' + chalk.hex(COLORS.border)('│'));
+    console.log(chalk.hex(COLORS.border)('  └─────────────────────────────────────────────────────────┘'));
+    console.log();
+  }
+
+  // Summary stats
+  console.log(chalk.hex(COLORS.border)('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log();
+  console.log(chalk.hex(COLORS.text)(`  ${demoData.summary.totalInferencePoints} inference points found`));
+  console.log(chalk.hex(COLORS.text)(`  ${demoData.issues.length} issues detected`));
+  console.log();
+
+  // Top issues
+  const criticalAndHigh = demoData.issues.filter(i => i.severity === 'critical' || i.severity === 'high');
+
+  for (const issue of criticalAndHigh.slice(0, 3)) {
+    const severityColor = issue.severity === 'critical'
+      ? chalk.hex(COLORS.critical)
+      : chalk.hex(COLORS.warning);
+
+    console.log(`  ${severityColor(issue.severity.toUpperCase())}: ${chalk.hex(COLORS.text)(issue.title)}`);
+    console.log(chalk.hex(COLORS.path)(`     ${issue.file}:${issue.line}`));
+    console.log(chalk.hex(COLORS.info)(`     ${issue.description}`));
+    if (issue.savings) {
+      console.log(chalk.hex(COLORS.success)(`     Potential savings: ${issue.savings}`));
+    }
+    console.log();
+  }
+
+  // Quick wins summary
+  console.log(chalk.hex(COLORS.success)('QUICK WINS:'));
+  console.log(chalk.hex(COLORS.text)(`  • Estimated savings: ${demoData.summary.estimatedMonthlySavings}`));
+  console.log(chalk.hex(COLORS.text)(`  • Latency improvement: ${demoData.summary.estimatedLatencyImprovement}`));
+  console.log();
+
+  // CTA
+  console.log(chalk.hex(COLORS.border)('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+  console.log();
+  console.log(chalk.hex(COLORS.text)('  Is YOUR code like this?'));
+  console.log();
+  console.log(chalk.hex(COLORS.text)('  Run on your codebase:'));
+  console.log(chalk.hex(COLORS.command)('    peakinfer analyze ./src'));
+  console.log();
+  console.log(chalk.hex(COLORS.info)('  Requires Anthropic API key. Set ANTHROPIC_API_KEY in .env'));
+  console.log();
+
+  const duration = Date.now() - startTime;
+  if (verbose) {
+    console.log(chalk.hex(COLORS.info)(`Demo completed in ${duration}ms`));
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

package/src/commands/export.ts

@@ -0,0 +1,297 @@
+/**
+ * Export Command (v1.6)
+ *
+ * CLI command for exporting analysis results in various formats:
+ * - inferencemap: InferenceMap v0.1 schema (default)
+ * - json: Full analysis results
+ * - prometheus: Prometheus metrics format
+ */
+
+import { Command } from 'commander';
+import { existsSync, writeFileSync } from 'fs';
+import { listRuns, loadRun } from '../history.js';
+import type { InferenceMap, Insight } from '../types.js';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+interface ExportOptions {
+  format: 'inferencemap' | 'json' | 'prometheus';
+  output?: string;
+  run?: string;
+}
+
+interface AnalysisExport {
+  inferenceMap?: InferenceMap;
+  insights?: Insight[];
+  runtime?: unknown;
+  joined?: unknown;
+}
+
+// =============================================================================
+// EXPORTERS
+// =============================================================================
+
+/**
+ * Export in InferenceMap v0.1 schema format
+ * Matches schemas/inference-map.v0.1.json
+ */
+function exportInferenceMap(data: AnalysisExport): string {
+  if (!data.inferenceMap) {
+    throw new Error('No inference map data available to export');
+  }
+
+  // InferenceMap v0.1 schema - preserve the original version
+  // The inferenceMap should already have version: "0.1"
+  const output = {
+    ...data.inferenceMap,
+    exportedAt: new Date().toISOString(),
+  };
+
+  return JSON.stringify(output, null, 2);
+}
+
+/**
+ * Export full analysis results as JSON
+ */
+function exportJSON(data: AnalysisExport): string {
+  const output = {
+    exportedAt: new Date().toISOString(),
+    format: 'peakinfer-analysis',
+    version: '1.0',
+    inferenceMap: data.inferenceMap,
+    insights: data.insights,
+    runtime: data.runtime,
+    joined: data.joined,
+  };
+
+  return JSON.stringify(output, null, 2);
+}
+
+/**
+ * Export in Prometheus metrics format
+ */
+function exportPrometheus(data: AnalysisExport): string {
+  const lines: string[] = [];
+  const timestamp = Date.now();
+
+  // Helper to add metric
+  const addMetric = (name: string, help: string, type: string, value: number, labels: Record<string, string> = {}) => {
+    lines.push(`# HELP ${name} ${help}`);
+    lines.push(`# TYPE ${name} ${type}`);
+
+    const labelStr = Object.entries(labels)
+      .map(([k, v]) => `${k}="${v}"`)
+      .join(',');
+
+    const fullName = labelStr ? `${name}{${labelStr}}` : name;
+    lines.push(`${fullName} ${value} ${timestamp}`);
+  };
+
+  if (data.inferenceMap) {
+    const map = data.inferenceMap;
+
+    // Total inference points
+    addMetric(
+      'peakinfer_inference_points_total',
+      'Total number of inference points detected',
+      'gauge',
+      map.summary.totalCallsites
+    );
+
+    // Providers
+    for (const provider of map.summary.providers) {
+      const count = map.callsites.filter(c => c.provider === provider).length;
+      addMetric(
+        'peakinfer_inference_points_by_provider',
+        'Inference points by provider',
+        'gauge',
+        count,
+        { provider }
+      );
+    }
+
+    // Models
+    for (const model of map.summary.models) {
+      const count = map.callsites.filter(c => c.model === model).length;
+      addMetric(
+        'peakinfer_inference_points_by_model',
+        'Inference points by model',
+        'gauge',
+        count,
+        { model }
+      );
+    }
+
+    // Patterns
+    for (const [pattern, count] of Object.entries(map.summary.patterns)) {
+      addMetric(
+        'peakinfer_pattern_usage',
+        'Pattern usage across inference points',
+        'gauge',
+        count,
+        { pattern }
+      );
+    }
+
+    // Average confidence
+    const avgConfidence = map.callsites.length > 0
+      ? map.callsites.reduce((sum, c) => sum + c.confidence, 0) / map.callsites.length
+      : 0;
+    addMetric(
+      'peakinfer_detection_confidence_avg',
+      'Average detection confidence (0-1)',
+      'gauge',
+      avgConfidence
+    );
+  }
+
+  // Insights by severity
+  if (data.insights) {
+    const bySeverity = {
+      critical: data.insights.filter(i => i.severity === 'critical').length,
+      warning: data.insights.filter(i => i.severity === 'warning').length,
+      info: data.insights.filter(i => i.severity === 'info').length,
+    };
+
+    for (const [severity, count] of Object.entries(bySeverity)) {
+      addMetric(
+        'peakinfer_insights_total',
+        'Total insights by severity',
+        'gauge',
+        count,
+        { severity }
+      );
+    }
+
+    // Insights by category
+    const byCategory: Record<string, number> = {};
+    for (const insight of data.insights) {
+      byCategory[insight.category] = (byCategory[insight.category] || 0) + 1;
+    }
+
+    for (const [category, count] of Object.entries(byCategory)) {
+      addMetric(
+        'peakinfer_insights_by_category',
+        'Insights by category',
+        'gauge',
+        count,
+        { category }
+      );
+    }
+  }
+
+  return lines.join('\n');
+}
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+/**
+ * Get the default output filename based on format
+ */
+function getDefaultFilename(format: string): string {
+  switch (format) {
+    case 'inferencemap':
+      return 'inference-map.json';
+    case 'prometheus':
+      return 'metrics.prom';
+    case 'json':
+    default:
+      return 'analysis.json';
+  }
+}
+
+/**
+ * Load analysis data from history or latest run
+ */
+function loadAnalysisData(runId?: string): AnalysisExport | null {
+  if (runId) {
+    // Load specific run
+    const run = loadRun(runId);
+    if (!run) {
+      return null;
+    }
+    return run.data;
+  }
+
+  // Load latest run
+  const runs = listRuns();
+  if (runs.length === 0) {
+    return null;
+  }
+
+  const latestRun = loadRun(runs[0].runId);
+  return latestRun?.data || null;
+}
+
+// =============================================================================
+// COMMAND
+// =============================================================================
+
+/**
+ * Register export command
+ */
+export function registerExportCommand(program: Command): void {
+  program
+    .command('export')
+    .description('export analysis results in various formats')
+    .option('--format <format>', 'output format: inferencemap (default), json, prometheus', 'inferencemap')
+    .option('--output <file>', 'output file path')
+    .option('--run <runId>', 'specific run to export (default: latest)')
+    .action(async (options: ExportOptions) => {
+      try {
+        // Validate format
+        const validFormats = ['inferencemap', 'json', 'prometheus'];
+        if (!validFormats.includes(options.format)) {
+          console.error(`Invalid format: ${options.format}`);
+          console.log(`Valid formats: ${validFormats.join(', ')}`);
+          process.exit(1);
+        }
+
+        // Load analysis data
+        const data = loadAnalysisData(options.run);
+        if (!data) {
+          console.error('No analysis data found.');
+          console.log('\nRun "peakinfer analyze ." first to generate analysis data.');
+          console.log('Or specify a run ID with --run <runId>');
+          process.exit(1);
+        }
+
+        // Export based on format
+        let output: string;
+        try {
+          switch (options.format) {
+            case 'inferencemap':
+              output = exportInferenceMap(data);
+              break;
+            case 'prometheus':
+              output = exportPrometheus(data);
+              break;
+            case 'json':
+            default:
+              output = exportJSON(data);
+          }
+        } catch (error) {
+          console.error('Export failed:', error instanceof Error ? error.message : 'Unknown error');
+          process.exit(1);
+        }
+
+        // Determine output destination
+        const outputFile = options.output || getDefaultFilename(options.format);
+
+        // Write to file or stdout
+        if (outputFile === '-') {
+          console.log(output);
+        } else {
+          writeFileSync(outputFile, output);
+          console.log(`Exported to ${outputFile} (${options.format} format)`);
+        }
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Export failed');
+        process.exit(1);
+      }
+    });
+}