@peakinfer/cli 1.0.133

package/src/commands/ci.ts

@@ -0,0 +1,336 @@
+/**
+ * CI Command (v1.6)
+ *
+ * CLI command for CI/CD integration:
+ * - Runs analysis with baseline comparison
+ * - Returns exit codes for CI gates
+ * - Outputs machine-readable JSON
+ *
+ * Exit codes:
+ * - 0: Pass (no regressions)
+ * - 1: Warning (minor regressions)
+ * - 2: Fail (major regressions)
+ */
+
+import { Command } from 'commander';
+import { existsSync, readFileSync } from 'fs';
+import { Agent } from '../agent.js';
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+interface CIOptions {
+  baseline?: string;
+  targetP95?: number;
+  failOnRegression?: boolean;
+  output?: string;
+  verbose?: boolean;
+}
+
+interface CIResult {
+  status: 'pass' | 'warning' | 'fail';
+  exitCode: number;
+  summary: {
+    inferencePoints: number;
+    estimatedMonthlyCost?: number;
+    p95Latency?: number;
+    driftCount?: number;
+    insightCount?: number;
+  };
+  baseline?: {
+    inferencePoints: number;
+    estimatedMonthlyCost?: number;
+    p95Latency?: number;
+  };
+  delta?: {
+    inferencePointsDelta: number;
+    costDeltaPercent?: number;
+    latencyDeltaPercent?: number;
+  };
+  regressions: string[];
+  improvements: string[];
+}
+
+interface BaselineData {
+  inferencePoints: number;
+  estimatedMonthlyCost?: number;
+  p95Latency?: number;
+  version?: string;
+  timestamp?: string;
+}
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+/**
+ * Load baseline from file
+ */
+function loadBaseline(path: string): BaselineData | null {
+  if (!existsSync(path)) {
+    return null;
+  }
+
+  try {
+    const content = readFileSync(path, 'utf-8');
+    const data = JSON.parse(content);
+
+    return {
+      inferencePoints: data.summary?.totalCallsites || data.inferencePoints || 0,
+      estimatedMonthlyCost: data.estimatedMonthlyCost,
+      p95Latency: data.p95Latency || data.global?.p95,
+      version: data.version,
+      timestamp: data.generatedAt || data.timestamp,
+    };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Determine CI status based on analysis results and baseline
+ */
+function determineCIStatus(
+  result: CIResult['summary'],
+  baseline: BaselineData | null,
+  options: CIOptions
+): CIResult {
+  const regressions: string[] = [];
+  const improvements: string[] = [];
+  let status: 'pass' | 'warning' | 'fail' = 'pass';
+
+  const ciResult: CIResult = {
+    status: 'pass',
+    exitCode: 0,
+    summary: result,
+    regressions,
+    improvements,
+  };
+
+  // Check target p95 if specified
+  if (options.targetP95 && result.p95Latency) {
+    if (result.p95Latency > options.targetP95) {
+      regressions.push(`p95 latency ${result.p95Latency}ms exceeds target ${options.targetP95}ms`);
+      status = 'fail';
+    }
+  }
+
+  // Compare with baseline if available
+  if (baseline) {
+    ciResult.baseline = {
+      inferencePoints: baseline.inferencePoints,
+      estimatedMonthlyCost: baseline.estimatedMonthlyCost,
+      p95Latency: baseline.p95Latency,
+    };
+
+    const inferencePointsDelta = result.inferencePoints - baseline.inferencePoints;
+
+    ciResult.delta = {
+      inferencePointsDelta,
+    };
+
+    // Check inference point changes
+    if (inferencePointsDelta > 0) {
+      improvements.push(`${inferencePointsDelta} new inference point${inferencePointsDelta !== 1 ? 's' : ''} detected`);
+    } else if (inferencePointsDelta < 0) {
+      improvements.push(`${Math.abs(inferencePointsDelta)} inference point${Math.abs(inferencePointsDelta) !== 1 ? 's' : ''} removed`);
+    }
+
+    // Check cost regression
+    if (baseline.estimatedMonthlyCost && result.estimatedMonthlyCost) {
+      const costDelta = result.estimatedMonthlyCost - baseline.estimatedMonthlyCost;
+      const costDeltaPercent = (costDelta / baseline.estimatedMonthlyCost) * 100;
+      ciResult.delta.costDeltaPercent = costDeltaPercent;
+
+      if (costDeltaPercent > 100) {
+        regressions.push(`Cost increased by ${costDeltaPercent.toFixed(0)}% (>${100}% threshold)`);
+        status = 'fail';
+      } else if (costDeltaPercent > 50) {
+        regressions.push(`Cost increased by ${costDeltaPercent.toFixed(0)}% (warning threshold)`);
+        if (status === 'pass') status = 'warning';
+      } else if (costDeltaPercent < -10) {
+        improvements.push(`Cost decreased by ${Math.abs(costDeltaPercent).toFixed(0)}%`);
+      }
+    }
+
+    // Check latency regression
+    if (baseline.p95Latency && result.p95Latency) {
+      const latencyDelta = result.p95Latency - baseline.p95Latency;
+      const latencyDeltaPercent = (latencyDelta / baseline.p95Latency) * 100;
+      ciResult.delta.latencyDeltaPercent = latencyDeltaPercent;
+
+      if (latencyDeltaPercent > 50) {
+        regressions.push(`p95 latency increased by ${latencyDeltaPercent.toFixed(0)}% (>${50}% threshold)`);
+        status = 'fail';
+      } else if (latencyDeltaPercent > 25) {
+        regressions.push(`p95 latency increased by ${latencyDeltaPercent.toFixed(0)}% (warning threshold)`);
+        if (status === 'pass') status = 'warning';
+      } else if (latencyDeltaPercent < -10) {
+        improvements.push(`p95 latency improved by ${Math.abs(latencyDeltaPercent).toFixed(0)}%`);
+      }
+    }
+  }
+
+  // Set final status and exit code
+  ciResult.status = status;
+  ciResult.exitCode = status === 'fail' ? 2 : status === 'warning' ? 1 : 0;
+
+  // Override exit code if --fail-on-regression is set
+  if (options.failOnRegression && regressions.length > 0) {
+    ciResult.exitCode = 2;
+    ciResult.status = 'fail';
+  }
+
+  return ciResult;
+}
+
+/**
+ * Format CI result for console output
+ */
+function formatCIResult(result: CIResult): string {
+  const lines: string[] = [];
+  const statusIndicator = result.status === 'pass' ? '[PASS]' : result.status === 'warning' ? '[WARN]' : '[FAIL]';
+
+  lines.push(`\n${statusIndicator} PeakInfer CI Check: ${result.status.toUpperCase()}`);
+  lines.push('═'.repeat(50));
+
+  lines.push('\nSummary:');
+  lines.push(`  Inference Points: ${result.summary.inferencePoints}`);
+  if (result.summary.estimatedMonthlyCost) {
+    lines.push(`  Est. Monthly Cost: $${result.summary.estimatedMonthlyCost.toLocaleString()}`);
+  }
+  if (result.summary.p95Latency) {
+    lines.push(`  p95 Latency: ${result.summary.p95Latency}ms`);
+  }
+  if (result.summary.driftCount) {
+    lines.push(`  Drift Signals: ${result.summary.driftCount}`);
+  }
+  if (result.summary.insightCount) {
+    lines.push(`  Insights: ${result.summary.insightCount}`);
+  }
+
+  if (result.delta) {
+    lines.push('\nChanges vs Baseline:');
+    lines.push(`  Inference Points: ${result.delta.inferencePointsDelta >= 0 ? '+' : ''}${result.delta.inferencePointsDelta}`);
+    if (result.delta.costDeltaPercent !== undefined) {
+      lines.push(`  Cost: ${result.delta.costDeltaPercent >= 0 ? '+' : ''}${result.delta.costDeltaPercent.toFixed(1)}%`);
+    }
+    if (result.delta.latencyDeltaPercent !== undefined) {
+      lines.push(`  p95 Latency: ${result.delta.latencyDeltaPercent >= 0 ? '+' : ''}${result.delta.latencyDeltaPercent.toFixed(1)}%`);
+    }
+  }
+
+  if (result.regressions.length > 0) {
+    lines.push('\nRegressions:');
+    for (const r of result.regressions) {
+      lines.push(`  - ${r}`);
+    }
+  }
+
+  if (result.improvements.length > 0) {
+    lines.push('\nImprovements:');
+    for (const i of result.improvements) {
+      lines.push(`  + ${i}`);
+    }
+  }
+
+  lines.push(`\nExit code: ${result.exitCode}`);
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// =============================================================================
+// COMMAND
+// =============================================================================
+
+/**
+ * Register CI command
+ */
+export function registerCICommand(program: Command): void {
+  program
+    .command('ci')
+    .description('run analysis in CI mode with exit codes')
+    .argument('<path>', 'path to analyze')
+    .option('--baseline <file>', 'baseline file for comparison (inference-map.json)')
+    .option('--target-p95 <ms>', 'target p95 latency in milliseconds', parseInt)
+    .option('--fail-on-regression', 'exit with code 2 on any regression')
+    .option('--output <format>', 'output format: text (default) or json', 'text')
+    .option('--verbose', 'show detailed output')
+    .action(async (path: string, options: CIOptions) => {
+      try {
+        // Validate path
+        if (!existsSync(path)) {
+          console.error(`Error: Path not found: ${path}`);
+          process.exit(2);
+        }
+
+        // Load baseline if provided
+        let baseline: BaselineData | null = null;
+        if (options.baseline) {
+          baseline = loadBaseline(options.baseline);
+          if (!baseline) {
+            console.error(`Warning: Could not load baseline from ${options.baseline}`);
+          }
+        }
+
+        // Define analysis result type
+        interface AnalysisResult {
+          inferenceMap?: { callsites: unknown[]; summary: { totalCallsites: number } };
+          insights?: unknown[];
+          joined?: { drift?: unknown[] };
+          runtime?: { global?: { p95: number } };
+        }
+
+        // Run analysis
+        const analysisResult = await new Promise<AnalysisResult | null>((resolve) => {
+          const agent = new Agent({
+            onComplete: (results: AnalysisResult) => {
+              resolve(results);
+            },
+            onError: (error: Error) => {
+              console.error(`Analysis error: ${error.message}`);
+              resolve(null);
+            },
+          });
+
+          agent.run({
+            path,
+            offline: false,
+            noCache: true,
+            verbose: options.verbose,
+            noHistory: true, // Don't save CI runs to history
+          });
+        });
+
+        if (!analysisResult) {
+          console.error('Analysis failed to produce results');
+          process.exit(2);
+        }
+
+        // Build summary
+        const summary: CIResult['summary'] = {
+          inferencePoints: analysisResult.inferenceMap?.summary?.totalCallsites || 0,
+          driftCount: analysisResult.joined?.drift?.length,
+          insightCount: analysisResult.insights?.length,
+          p95Latency: analysisResult.runtime?.global?.p95,
+        };
+
+        // Determine CI status
+        const ciResult = determineCIStatus(summary, baseline, options);
+
+        // Output result
+        if (options.output === 'json') {
+          console.log(JSON.stringify(ciResult, null, 2));
+        } else {
+          console.log(formatCIResult(ciResult));
+        }
+
+        process.exit(ciResult.exitCode);
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'CI check failed');
+        process.exit(2);
+      }
+    });
+}

package/src/commands/config.ts

@@ -0,0 +1,288 @@
+/**
+ * Config Commands (v1.6)
+ *
+ * CLI commands for managing PeakInfer configuration:
+ * - set: Set a configuration value
+ * - show: Display current configuration
+ *
+ * Configuration resolution chain:
+ * CLI flags → env vars → ~/.peakinfer/config.yaml → ./peakinfer.yaml → defaults
+ */
+
+import { Command } from 'commander';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { parse as parseYAML, stringify as stringifyYAML } from 'yaml';
+
+// =============================================================================
+// CONSTANTS
+// =============================================================================
+
+const GLOBAL_CONFIG_DIR = join(homedir(), '.peakinfer');
+const GLOBAL_CONFIG_FILE = join(GLOBAL_CONFIG_DIR, 'config.yaml');
+const LOCAL_CONFIG_FILE = 'peakinfer.yaml';
+
+// Allowed configuration keys
+const ALLOWED_KEYS = [
+  'api-key',
+  'model',
+  'mode',
+  'verbose',
+  'history-retention-days',
+] as const;
+
+type ConfigKey = typeof ALLOWED_KEYS[number];
+
+// Internal key mapping (CLI name → config key)
+const KEY_MAP: Record<string, string> = {
+  'api-key': 'apiKey',
+  'model': 'model',
+  'mode': 'analysisMode',
+  'verbose': 'verbose',
+  'history-retention-days': 'historyRetentionDays',
+};
+
+// =============================================================================
+// TYPES
+// =============================================================================
+
+interface ConfigFile {
+  apiKey?: string;
+  model?: string;
+  analysisMode?: string;
+  verbose?: boolean;
+  historyRetentionDays?: number;
+}
+
+// =============================================================================
+// HELPERS
+// =============================================================================
+
+/**
+ * Load global config file
+ */
+function loadGlobalConfig(): ConfigFile {
+  if (!existsSync(GLOBAL_CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(GLOBAL_CONFIG_FILE, 'utf-8');
+    return parseYAML(content) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Load local config file
+ */
+function loadLocalConfig(): ConfigFile {
+  if (!existsSync(LOCAL_CONFIG_FILE)) {
+    return {};
+  }
+  try {
+    const content = readFileSync(LOCAL_CONFIG_FILE, 'utf-8');
+    return parseYAML(content) || {};
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Save global config file
+ */
+function saveGlobalConfig(config: ConfigFile): void {
+  mkdirSync(GLOBAL_CONFIG_DIR, { recursive: true });
+  writeFileSync(GLOBAL_CONFIG_FILE, stringifyYAML(config));
+}
+
+/**
+ * Save local config file
+ */
+function saveLocalConfig(config: ConfigFile): void {
+  writeFileSync(LOCAL_CONFIG_FILE, stringifyYAML(config));
+}
+
+/**
+ * Get merged configuration with resolution chain
+ */
+function getMergedConfig(): ConfigFile & { _sources: Record<string, string> } {
+  const defaults: ConfigFile = {
+    model: 'claude-sonnet-4-20250514',
+    analysisMode: 'agent',
+    verbose: false,
+    historyRetentionDays: 90,
+  };
+
+  const local = loadLocalConfig();
+  const global = loadGlobalConfig();
+
+  // Track where each value comes from
+  const sources: Record<string, string> = {};
+
+  const result: ConfigFile = {};
+
+  // Resolution: defaults → global → local → env
+  for (const key of Object.keys(defaults) as (keyof ConfigFile)[]) {
+    if (key in defaults) {
+      result[key] = defaults[key] as never;
+      sources[key] = 'default';
+    }
+    if (key in global && global[key] !== undefined) {
+      result[key] = global[key] as never;
+      sources[key] = 'global (~/.peakinfer/config.yaml)';
+    }
+    if (key in local && local[key] !== undefined) {
+      result[key] = local[key] as never;
+      sources[key] = 'local (./peakinfer.yaml)';
+    }
+  }
+
+  // Environment variable overrides
+  if (process.env.ANTHROPIC_API_KEY) {
+    result.apiKey = process.env.ANTHROPIC_API_KEY;
+    sources['apiKey'] = 'env (ANTHROPIC_API_KEY)';
+  }
+  if (process.env.PEAKINFER_MODEL) {
+    result.model = process.env.PEAKINFER_MODEL;
+    sources['model'] = 'env (PEAKINFER_MODEL)';
+  }
+  if (process.env.PEAKINFER_MODE) {
+    result.analysisMode = process.env.PEAKINFER_MODE;
+    sources['analysisMode'] = 'env (PEAKINFER_MODE)';
+  }
+  if (process.env.PEAKINFER_VERBOSE === '1' || process.env.PEAKINFER_VERBOSE === 'true') {
+    result.verbose = true;
+    sources['verbose'] = 'env (PEAKINFER_VERBOSE)';
+  }
+
+  return { ...result, _sources: sources };
+}
+
+/**
+ * Mask sensitive values for display
+ */
+function maskValue(key: string, value: unknown): string {
+  if (key === 'apiKey' && typeof value === 'string') {
+    if (value.length > 8) {
+      return value.slice(0, 4) + '...' + value.slice(-4);
+    }
+    return '****';
+  }
+  return String(value);
+}
+
+/**
+ * Format config for display
+ */
+function displayConfig(config: ConfigFile & { _sources: Record<string, string> }): void {
+  console.log('\nPeakInfer Configuration');
+  console.log('═'.repeat(60));
+
+  const { _sources, ...values } = config;
+
+  const displayKeys: Array<{ key: keyof ConfigFile; label: string }> = [
+    { key: 'apiKey', label: 'API Key' },
+    { key: 'model', label: 'Model' },
+    { key: 'analysisMode', label: 'Analysis Mode' },
+    { key: 'verbose', label: 'Verbose' },
+    { key: 'historyRetentionDays', label: 'History Retention' },
+  ];
+
+  for (const { key, label } of displayKeys) {
+    const value = values[key];
+    const source = _sources[key];
+
+    if (value !== undefined) {
+      const displayValue = maskValue(key, value);
+      const suffix = key === 'historyRetentionDays' ? ' days' : '';
+      console.log(`  ${label.padEnd(20)} ${displayValue}${suffix}`);
+      console.log(`  ${''.padEnd(20)} └─ source: ${source}`);
+    } else {
+      console.log(`  ${label.padEnd(20)} (not set)`);
+    }
+  }
+
+  console.log('');
+  console.log('Resolution chain: CLI → env → global → local → defaults');
+  console.log('');
+}
+
+// =============================================================================
+// COMMANDS
+// =============================================================================
+
+/**
+ * Register config commands
+ */
+export function registerConfigCommands(program: Command): void {
+  const configCmd = program
+    .command('config')
+    .description('manage configuration');
+
+  // Set config value
+  configCmd
+    .command('set')
+    .description('set a configuration value')
+    .argument('<key>', `configuration key (${ALLOWED_KEYS.join(', ')})`)
+    .argument('<value>', 'configuration value')
+    .option('--global', 'save to global config (~/.peakinfer/config.yaml)', true)
+    .option('--local', 'save to local config (./peakinfer.yaml)')
+    .action((key: string, value: string, options: { global?: boolean; local?: boolean }) => {
+      try {
+        // Validate key
+        if (!ALLOWED_KEYS.includes(key as ConfigKey)) {
+          console.error(`Invalid key: ${key}`);
+          console.log(`\nAllowed keys: ${ALLOWED_KEYS.join(', ')}`);
+          process.exit(1);
+        }
+
+        const configKey = KEY_MAP[key] || key;
+
+        // Parse value based on key
+        let parsedValue: string | number | boolean = value;
+        if (key === 'verbose') {
+          parsedValue = value === 'true' || value === '1';
+        } else if (key === 'history-retention-days') {
+          parsedValue = parseInt(value, 10);
+          if (isNaN(parsedValue)) {
+            console.error('history-retention-days must be a number');
+            process.exit(1);
+          }
+        }
+
+        // Determine target file
+        const useLocal = options.local && !options.global;
+
+        if (useLocal) {
+          const config = loadLocalConfig();
+          (config as Record<string, unknown>)[configKey] = parsedValue;
+          saveLocalConfig(config);
+          console.log(`Set ${key} = ${maskValue(configKey, parsedValue)} in ./peakinfer.yaml`);
+        } else {
+          const config = loadGlobalConfig();
+          (config as Record<string, unknown>)[configKey] = parsedValue;
+          saveGlobalConfig(config);
+          console.log(`Set ${key} = ${maskValue(configKey, parsedValue)} in ~/.peakinfer/config.yaml`);
+        }
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Failed to set config');
+        process.exit(1);
+      }
+    });
+
+  // Show config
+  configCmd
+    .command('show')
+    .description('display current configuration')
+    .action(() => {
+      try {
+        const config = getMergedConfig();
+        displayConfig(config);
+      } catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : 'Failed to load config');
+        process.exit(1);
+      }
+    });
+}