@peakinfer/cli 1.0.133

package/tests/action/commands.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { parseCommand } from '../../src/action/commands.js';
+
+// =============================================================================
+// COMMAND PARSING TESTS
+// =============================================================================
+
+describe('parseCommand', () => {
+  describe('/peakinfer command', () => {
+    it('parses /peakinfer as rerun', () => {
+      const cmd = parseCommand('/peakinfer');
+      expect(cmd).toEqual({ type: 'rerun' });
+    });
+
+    it('parses /peakinfer rerun as rerun', () => {
+      const cmd = parseCommand('/peakinfer rerun');
+      expect(cmd).toEqual({ type: 'rerun' });
+    });
+
+    it('is case insensitive', () => {
+      const cmd = parseCommand('/PEAKINFER');
+      expect(cmd).toEqual({ type: 'rerun' });
+    });
+
+    it('trims whitespace', () => {
+      const cmd = parseCommand('  /peakinfer  ');
+      expect(cmd).toEqual({ type: 'rerun' });
+    });
+  });
+
+  describe('/fix command', () => {
+    it('parses /fix <id> correctly', () => {
+      const cmd = parseCommand('/fix 1');
+      expect(cmd).toEqual({ type: 'fix', issueId: 1 });
+    });
+
+    it('parses /fix with larger ids', () => {
+      const cmd = parseCommand('/fix 123');
+      expect(cmd).toEqual({ type: 'fix', issueId: 123 });
+    });
+
+    it('parses /peakinfer fix <id>', () => {
+      const cmd = parseCommand('/peakinfer fix 5');
+      expect(cmd).toEqual({ type: 'fix', issueId: 5 });
+    });
+
+    it('parses /fix all as fix-all', () => {
+      const cmd = parseCommand('/fix all');
+      expect(cmd).toEqual({ type: 'fix-all' });
+    });
+
+    it('parses /peakinfer fix all', () => {
+      const cmd = parseCommand('/peakinfer fix all');
+      expect(cmd).toEqual({ type: 'fix-all' });
+    });
+  });
+
+  describe('/dismiss command', () => {
+    it('parses /dismiss <id> correctly', () => {
+      const cmd = parseCommand('/dismiss 2');
+      expect(cmd).toEqual({ type: 'dismiss', issueId: 2 });
+    });
+
+    it('parses /peakinfer dismiss <id>', () => {
+      const cmd = parseCommand('/peakinfer dismiss 7');
+      expect(cmd).toEqual({ type: 'dismiss', issueId: 7 });
+    });
+  });
+
+  describe('non-commands', () => {
+    it('returns null for regular comments', () => {
+      expect(parseCommand('Great work on this PR!')).toBeNull();
+    });
+
+    it('returns null for partial commands', () => {
+      expect(parseCommand('/fix')).toBeNull();
+      expect(parseCommand('/dismiss')).toBeNull();
+    });
+
+    it('returns null for invalid ids', () => {
+      expect(parseCommand('/fix abc')).toBeNull();
+      expect(parseCommand('/dismiss xyz')).toBeNull();
+    });
+
+    it('returns null for empty string', () => {
+      expect(parseCommand('')).toBeNull();
+    });
+
+    it('returns null for comments mentioning peakinfer', () => {
+      expect(parseCommand('can you run peakinfer again?')).toBeNull();
+    });
+  });
+});
+
+// =============================================================================
+// COMMAND SCENARIOS
+// =============================================================================
+
+describe('Command Scenarios', () => {
+  it('user wants to re-run analysis after fixing issues', () => {
+    // User pushes fixes, then comments to re-analyze
+    const cmd = parseCommand('/peakinfer');
+    expect(cmd?.type).toBe('rerun');
+  });
+
+  it('user wants to accept a specific fix', () => {
+    // User reviews the top issue and accepts it
+    const cmd = parseCommand('/fix 1');
+    expect(cmd?.type).toBe('fix');
+    expect(cmd?.issueId).toBe(1);
+  });
+
+  it('user wants to dismiss an issue they disagree with', () => {
+    // User thinks the issue is a false positive
+    const cmd = parseCommand('/dismiss 3');
+    expect(cmd?.type).toBe('dismiss');
+    expect(cmd?.issueId).toBe(3);
+  });
+
+  it('user wants to accept all available fixes', () => {
+    // User trusts all suggestions and wants to apply them
+    const cmd = parseCommand('/fix all');
+    expect(cmd?.type).toBe('fix-all');
+  });
+});

package/tests/action/comments.test.ts

@@ -0,0 +1,347 @@
+import { describe, it, expect } from 'vitest';
+import { generatePRComment, generateExhaustedComment } from '../../src/action/comments.js';
+import type { Insight } from '../../src/types.js';
+
+// =============================================================================
+// HELPER: Create mock insight
+// =============================================================================
+
+function createInsight(overrides: Partial<Insight> = {}): Insight {
+  return {
+    templateId: overrides.templateId || 'test-template',
+    headline: overrides.headline || 'Test issue headline',
+    evidence: overrides.evidence || 'Test evidence',
+    severity: overrides.severity || 'warning',
+    category: overrides.category || 'cost',
+    location: overrides.location || 'src/test.ts:10',
+    recommendation: overrides.recommendation,
+  };
+}
+
+// =============================================================================
+// VERDICT TESTS
+// =============================================================================
+
+describe('Verdict Logic', () => {
+  it('returns "Safe to Merge" when no issues', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 5, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'pass',
+      regressions: [],
+      newIssues: [],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('✅ Safe to Merge');
+    expect(comment).toContain('No issues found');
+    expect(comment).toContain('5 inference points');
+  });
+
+  it('returns "Mostly Good" for 1-5 warnings', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'warning', headline: 'Warning 1' }),
+        createInsight({ severity: 'warning', headline: 'Warning 2' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('🟢 Mostly Good');
+    expect(comment).toContain('2 optional improvements');
+  });
+
+  it('returns "Review Recommended" for 1 critical issue', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'critical', headline: 'Critical issue' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('🟡 Review Recommended');
+    expect(comment).toContain('1 issue needs attention');
+  });
+
+  it('returns "Review Recommended" for >5 warnings', () => {
+    const warnings = Array(7).fill(null).map((_, i) =>
+      createInsight({ severity: 'warning', headline: `Warning ${i + 1}` })
+    );
+
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: warnings,
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('🟡 Review Recommended');
+    expect(comment).toContain('7 improvements suggested');
+  });
+
+  it('returns "Changes Requested" for ≥2 critical issues', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'fail',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'critical', headline: 'Critical 1' }),
+        createInsight({ severity: 'critical', headline: 'Critical 2' }),
+        createInsight({ severity: 'critical', headline: 'Critical 3' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('🔴 Changes Requested');
+    expect(comment).toContain('3 issues need attention before merge');
+  });
+});
+
+// =============================================================================
+// TOP ISSUE TESTS
+// =============================================================================
+
+describe('Top Issue Highlight', () => {
+  it('shows the highest severity issue first', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'info', headline: 'Info issue' }),
+        createInsight({ severity: 'critical', headline: 'Critical issue', location: 'src/api.ts:45' }),
+        createInsight({ severity: 'warning', headline: 'Warning issue' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('**Top Issue**');
+    expect(comment).toContain('Critical issue');
+    expect(comment).toContain('`src/api.ts:45`');
+  });
+
+  it('shows evidence as "Why it matters"', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({
+          severity: 'critical',
+          headline: 'Missing error handling',
+          evidence: 'Unhandled failures will crash the service',
+        }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('**Why it matters**');
+    expect(comment).toContain('Unhandled failures will crash the service');
+  });
+});
+
+// =============================================================================
+// COLLAPSIBLE DETAILS TESTS
+// =============================================================================
+
+describe('Collapsible Details', () => {
+  it('does not show details section for single issue', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'critical', headline: 'Single issue' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).not.toContain('<details>');
+  });
+
+  it('shows collapsible details for multiple issues', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'critical', headline: 'Critical 1' }),
+        createInsight({ severity: 'warning', headline: 'Warning 1' }),
+        createInsight({ severity: 'warning', headline: 'Warning 2' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('<details>');
+    expect(comment).toContain('See all 3 issues');
+    expect(comment).toContain('</details>');
+  });
+
+  it('groups issues by severity in details', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'critical', headline: 'Critical 1' }),
+        createInsight({ severity: 'critical', headline: 'Critical 2' }),
+        createInsight({ severity: 'warning', headline: 'Warning 1' }),
+        createInsight({ severity: 'info', headline: 'Info 1' }),
+      ],
+      changedFiles: [],
+    });
+
+    // Critical shown as top issue, so details shows remaining:
+    // 1 critical, 1 warning, 1 info
+    expect(comment).toContain('**Critical**');
+    expect(comment).toContain('**Warning**');
+    expect(comment).toContain('**Info**');
+  });
+});
+
+// =============================================================================
+// COMMANDS FOOTER TESTS
+// =============================================================================
+
+describe('Commands Footer', () => {
+  it('shows commands when issues exist', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'warning',
+      regressions: [],
+      newIssues: [
+        createInsight({ severity: 'warning', headline: 'Test issue' }),
+      ],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('/fix 1');
+    expect(comment).toContain('/dismiss 1');
+    expect(comment).toContain('/fix all');
+    expect(comment).toContain('/peakinfer');
+  });
+
+  it('does not show commands when no issues', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'pass',
+      regressions: [],
+      newIssues: [],
+      changedFiles: [],
+    });
+
+    expect(comment).not.toContain('/fix');
+    expect(comment).not.toContain('/dismiss');
+  });
+
+  it('always includes PeakInfer attribution', () => {
+    const comment = generatePRComment({
+      results: {
+        inferenceMap: {
+          callsites: [],
+          summary: { totalCallsites: 3, providers: ['openai'], models: ['gpt-4'] },
+        },
+      },
+      baseline: null,
+      status: 'pass',
+      regressions: [],
+      newIssues: [],
+      changedFiles: [],
+    });
+
+    expect(comment).toContain('Generated by');
+    expect(comment).toContain('PeakInfer');
+  });
+});
+
+// =============================================================================
+// EXHAUSTED CREDITS TESTS
+// =============================================================================
+
+describe('Exhausted Credits Comment', () => {
+  it('shows usage and alternatives', () => {
+    const comment = generateExhaustedComment(300, 300);
+
+    expect(comment).toContain('Free Tier Limit Reached');
+    expect(comment).toContain('300/300');
+    expect(comment).toContain('npm i -g @kalmantic/peakinfer');
+  });
+});

package/tests/cli.test.ts

@@ -0,0 +1,203 @@
+/**
+ * CLI Integration Tests
+ * Per Test Cases v1.9.3 - Critical Path Tests
+ */
+import { describe, test, expect, beforeAll, afterAll } from 'vitest';
+import { spawn, ChildProcess } from 'child_process';
+import { join } from 'path';
+import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
+
+const CLI_PATH = join(__dirname, '..', 'dist', 'cli.js');
+const FIXTURES_PATH = join(__dirname, 'fixtures');
+const TEMP_DIR = join(__dirname, '.temp-cli-test');
+
+interface CLIResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+  duration: number;
+}
+
+async function runCLI(args: string[], options?: { env?: Record<string, string>; timeout?: number }): Promise<CLIResult> {
+  return new Promise((resolve, reject) => {
+    const startTime = Date.now();
+    const timeout = options?.timeout || 60000;
+
+    const child = spawn('node', [CLI_PATH, ...args], {
+      env: { ...process.env, ...options?.env },
+      cwd: process.cwd(),
+    });
+
+    let stdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data) => {
+      stdout += data.toString();
+    });
+
+    child.stderr.on('data', (data) => {
+      stderr += data.toString();
+    });
+
+    const timer = setTimeout(() => {
+      child.kill();
+      reject(new Error(`CLI timed out after ${timeout}ms`));
+    }, timeout);
+
+    child.on('close', (code) => {
+      clearTimeout(timer);
+      resolve({
+        exitCode: code || 0,
+        stdout,
+        stderr,
+        duration: Date.now() - startTime,
+      });
+    });
+
+    child.on('error', (err) => {
+      clearTimeout(timer);
+      reject(err);
+    });
+  });
+}
+
+describe('CLI demo command', () => {
+  test('Runs without arguments', async () => {
+    const result = await runCLI(['demo']);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('DRIFT DETECTED');
+  });
+
+  test('Completes in under 30 seconds', async () => {
+    const result = await runCLI(['demo']);
+    expect(result.duration).toBeLessThan(30000);
+  });
+
+  test('Works offline with cached demo data', async () => {
+    const result = await runCLI(['demo'], {
+      env: {
+        ANTHROPIC_API_KEY: '', // No API key
+      },
+    });
+
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('inference points');
+    expect(result.stderr).not.toContain('API');
+  });
+
+  test('Shows magic moment (drift detection)', async () => {
+    const result = await runCLI(['demo']);
+    expect(result.stdout).toContain('YOUR CODE');
+    expect(result.stdout).toContain('RUNTIME');
+  });
+
+  test('Shows issues with severity', async () => {
+    const result = await runCLI(['demo']);
+    expect(result.stdout).toMatch(/CRITICAL|HIGH|MEDIUM|LOW/);
+  });
+
+  test('Shows CTA for next step', async () => {
+    const result = await runCLI(['demo']);
+    expect(result.stdout).toContain('peakinfer analyze');
+  });
+});
+
+describe('CLI help', () => {
+  test('Shows help with --help', async () => {
+    const result = await runCLI(['--help']);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toContain('analyze');
+    expect(result.stdout).toContain('demo');
+  });
+
+  test('Shows version with --version', async () => {
+    const result = await runCLI(['--version']);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/\d+\.\d+\.\d+/);
+  });
+});
+
+describe('CLI analyze command', () => {
+  beforeAll(() => {
+    // Create temp directory with test file
+    if (!existsSync(TEMP_DIR)) {
+      mkdirSync(TEMP_DIR, { recursive: true });
+    }
+
+    // Create a simple test file
+    const testFile = `
+import Anthropic from '@anthropic-ai/sdk';
+
+const client = new Anthropic();
+
+export async function chat(prompt: string) {
+  const response = await client.messages.create({
+    model: 'claude-sonnet-4-20250514',
+    max_tokens: 1000,
+    messages: [{ role: 'user', content: prompt }],
+  });
+  return response;
+}
+`;
+    writeFileSync(join(TEMP_DIR, 'test.ts'), testFile);
+  });
+
+  afterAll(() => {
+    // Cleanup
+    if (existsSync(TEMP_DIR)) {
+      rmSync(TEMP_DIR, { recursive: true, force: true });
+    }
+  });
+
+  test('Fails gracefully without API key', async () => {
+    const result = await runCLI(['analyze', TEMP_DIR], {
+      env: {
+        ANTHROPIC_API_KEY: '',
+      },
+    });
+    // Should exit with error or show helpful message
+    expect(result.stdout + result.stderr).toMatch(/API|key|ANTHROPIC/i);
+  });
+
+  test('Shows error for non-existent path', async () => {
+    const result = await runCLI(['analyze', '/non/existent/path']);
+    expect(result.exitCode).not.toBe(0);
+    expect(result.stderr).toContain('not found');
+  });
+
+  test('Accepts --verbose flag', async () => {
+    const result = await runCLI(['analyze', TEMP_DIR, '--verbose'], {
+      env: {
+        ANTHROPIC_API_KEY: '',
+      },
+    });
+    // Should not crash with verbose flag
+    expect(result.exitCode).toBeDefined();
+  });
+
+  test('Accepts --fixes flag', async () => {
+    const result = await runCLI(['analyze', TEMP_DIR, '--fixes'], {
+      env: {
+        ANTHROPIC_API_KEY: '',
+      },
+    });
+    // Should not crash with fixes flag
+    expect(result.exitCode).toBeDefined();
+  });
+});
+
+describe('CLI template commands', () => {
+  test('Lists templates', async () => {
+    const result = await runCLI(['template', 'list']);
+    expect(result.exitCode).toBe(0);
+    expect(result.stdout).toMatch(/template|insight|optimization/i);
+  });
+});
+
+describe('CLI history commands', () => {
+  test('Shows history', async () => {
+    const result = await runCLI(['history']);
+    expect(result.exitCode).toBe(0);
+    // May be empty but should not crash
+  });
+});