faf-taf-git 2.0.4 → 2.2.2

package/src/parsers/bun.ts

@@ -0,0 +1,103 @@
+/**
+ * Bun test output parser
+ *
+ * Extracts test counts from `bun test` CLI output.
+ */
+
+import { TestResults } from './jest';
+
+/**
+ * Parse Bun test output to extract test results.
+ *
+ * Bun output format (summary block at the end of a run):
+ *
+ * ```
+ *    232 pass
+ *    1 skip
+ *    1 todo
+ *    0 fail
+ *    848 expect() calls
+ *   Ran 234 tests across 9 files. [21.53s]
+ * ```
+ *
+ * Notes:
+ * - Anchored on `Ran <N> tests across <M> files.` — the canonical truthful
+ *   total (includes skip + todo + pass + fail). Without this line, the parser
+ *   returns null and the dispatcher falls through to jest/vitest.
+ * - Per-category counts (`pass`, `fail`, `skip`, `todo`) come from their own
+ *   lines elsewhere in the same output. Singular forms — bun does not use
+ *   `passed`/`failed`/`skipped` (intentional differentiator from jest/vitest).
+ * - `skipped` aggregates `skip` + `todo` (matches the convention vitest.ts
+ *   already uses for parity in the shared TestResults shape).
+ */
+export function parseBunOutput(output: string): TestResults | null {
+  // Strip ANSI color codes + normalize line endings (parity with siblings).
+  // eslint-disable-next-line no-control-regex
+  let cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+  cleanOutput = cleanOutput.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+  // Canonical anchor: bun-unique "Ran N tests across M files." summary line.
+  // Without this, this isn't bun output — let the dispatcher try the others.
+  const ranMatch = cleanOutput.match(/^Ran\s+(\d+)\s+tests?\s+across\s+\d+\s+files?/m);
+  if (!ranMatch) return null;
+
+  const total = parseInt(ranMatch[1], 10);
+  if (total === 0) return null;
+
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+
+  // Per-line counts. Each line is `<leading-ws><N> <singular-word>` on its own.
+  // Anchored with ^...$ + multiline to avoid catching the "expect() calls" line
+  // or any noise inside test descriptions.
+  const passedMatch = cleanOutput.match(/^\s*(\d+)\s+pass\s*$/m);
+  if (passedMatch) passed = parseInt(passedMatch[1], 10);
+
+  const failedMatch = cleanOutput.match(/^\s*(\d+)\s+fail\s*$/m);
+  if (failedMatch) failed = parseInt(failedMatch[1], 10);
+
+  const skipMatch = cleanOutput.match(/^\s*(\d+)\s+skip\s*$/m);
+  if (skipMatch) skipped += parseInt(skipMatch[1], 10);
+
+  const todoMatch = cleanOutput.match(/^\s*(\d+)\s+todo\s*$/m);
+  if (todoMatch) skipped += parseInt(todoMatch[1], 10);
+
+  const result: 'PASSED' | 'FAILED' = failed > 0 ? 'FAILED' : 'PASSED';
+
+  return {
+    total,
+    passed,
+    failed,
+    skipped: skipped > 0 ? skipped : undefined,
+    result,
+  };
+}
+
+/**
+ * Example Bun outputs for testing:
+ *
+ * All passing:
+ * ```
+ *  173 pass
+ *  0 fail
+ *  Ran 173 tests across 8 files. [4.2s]
+ * ```
+ *
+ * Mixed (the grok-faf-mcp 1.4.9 shape):
+ * ```
+ *  232 pass
+ *  1 skip
+ *  1 todo
+ *  0 fail
+ *  848 expect() calls
+ *  Ran 234 tests across 9 files. [21.53s]
+ * ```
+ *
+ * Failing:
+ * ```
+ *  170 pass
+ *  3 fail
+ *  Ran 173 tests across 8 files. [5.1s]
+ * ```
+ */

package/src/parsers/index.ts

@@ -0,0 +1,27 @@
+/**
+ * Unified test output parser
+ *
+ * Tries each framework parser in order until one succeeds.
+ */
+
+import { TestResults } from './jest';
+import { parseBunOutput } from './bun';
+import { parseJestOutput } from './jest';
+import { parseVitestOutput } from './vitest';
+
+export { TestResults } from './jest';
+
+/**
+ * Parse test output from any supported framework.
+ *
+ * Order matters: Bun is tried first because its `Ran N tests across M files`
+ * anchor is bun-unique — it never false-matches on jest/vitest output. Putting
+ * it first also lets bun consumers ship truthful totals even when their CI
+ * still has a legacy `Tests: N passed, N total` jest-shim line appended to the
+ * test output (the bun parser ignores it and reads the canonical `Ran` line).
+ *
+ * Tries parsers in order: Bun, Jest, Vitest.
+ */
+export function parseTestOutput(output: string): TestResults | null {
+  return parseBunOutput(output) || parseJestOutput(output) || parseVitestOutput(output);
+}

package/src/parsers/vitest.ts

@@ -0,0 +1,65 @@
+/**
+ * Vitest output parser
+ *
+ * Extracts test counts from Vitest CLI output
+ */
+
+import { TestResults } from './jest';
+
+/**
+ * Parse Vitest output to extract test results
+ *
+ * Vitest output formats:
+ * - " Tests  8 passed (8)"
+ * - " Tests  2 failed | 6 passed (8)"
+ * - " Tests  1 skipped | 7 passed (8)"
+ * - " Tests  1 failed | 2 skipped | 5 passed (8)"
+ */
+export function parseVitestOutput(output: string): TestResults | null {
+  // Strip ANSI color codes
+  // eslint-disable-next-line no-control-regex
+  let cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+  cleanOutput = cleanOutput.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+  // Vitest summary pattern: " Tests  ... (N)" where N is total in parens
+  const testSummaryPattern = /^\s*Tests\s+(.+?\(\d+\))/m;
+  const testLineMatch = cleanOutput.match(testSummaryPattern);
+
+  if (!testLineMatch || !testLineMatch[1]) {
+    return null;
+  }
+
+  const testLine = testLineMatch[1];
+
+  // Extract total from parentheses at end
+  const totalMatch = testLine.match(/\((\d+)\)\s*$/);
+  if (!totalMatch) return null;
+  const total = parseInt(totalMatch[1], 10);
+  if (total === 0) return null;
+
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+
+  const passedMatch = testLine.match(/(\d+)\s+passed/i);
+  if (passedMatch) passed = parseInt(passedMatch[1], 10);
+
+  const failedMatch = testLine.match(/(\d+)\s+failed/i);
+  if (failedMatch) failed = parseInt(failedMatch[1], 10);
+
+  const skippedMatch = testLine.match(/(\d+)\s+skipped/i);
+  if (skippedMatch) skipped = parseInt(skippedMatch[1], 10);
+
+  const todoMatch = testLine.match(/(\d+)\s+todo/i);
+  if (todoMatch) skipped += parseInt(todoMatch[1], 10);
+
+  let result: 'PASSED' | 'FAILED' = failed > 0 ? 'FAILED' : 'PASSED';
+
+  return {
+    total,
+    passed,
+    failed,
+    skipped: skipped > 0 ? skipped : undefined,
+    result,
+  };
+}

package/tests/badge.test.ts

@@ -0,0 +1,260 @@
+/**
+ * Badge Generator Tests
+ *
+ * Tests SVG output validity, .taf parsing, and edge cases.
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { renderBadgeSvg, generateBadge } from '../src/badge';
+
+function createTempDir(prefix: string): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// SVG RENDERING
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+describe('SVG Rendering', () => {
+  test('should produce valid SVG with label and value', () => {
+    const svg = renderBadgeSvg('TAF', '10/10 passing', '#003366');
+
+    expect(svg).toContain('<svg');
+    expect(svg).toContain('</svg>');
+    expect(svg).toContain('TAF');
+    expect(svg).toContain('10/10 passing');
+  });
+
+  test('should include correct color', () => {
+    const svg = renderBadgeSvg('TAF', '10/10 passing', '#003366');
+
+    expect(svg).toContain('fill="#003366"');
+  });
+
+  test('should include accessibility attributes', () => {
+    const svg = renderBadgeSvg('TAF', '5/5 passing', '#003366');
+
+    expect(svg).toContain('role="img"');
+    expect(svg).toContain('aria-label="TAF: 5/5 passing"');
+    expect(svg).toContain('<title>TAF: 5/5 passing</title>');
+  });
+
+  test('should use Verdana font', () => {
+    const svg = renderBadgeSvg('TAF', 'test', '#555');
+
+    expect(svg).toContain('Verdana');
+  });
+
+  test('should have 20px height', () => {
+    const svg = renderBadgeSvg('TAF', 'test', '#555');
+
+    expect(svg).toContain('height="20"');
+  });
+
+  test('should have rounded corners via clipPath', () => {
+    const svg = renderBadgeSvg('TAF', 'test', '#555');
+
+    expect(svg).toContain('rx="3"');
+    expect(svg).toContain('clip-path="url(#r)"');
+  });
+
+  test('should handle custom label', () => {
+    const svg = renderBadgeSvg('tests', '99/100 passing', '#E32400');
+
+    expect(svg).toContain('tests');
+    expect(svg).toContain('99/100 passing');
+    expect(svg).toContain('#E32400');
+  });
+});
+
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+// BADGE GENERATION FROM .taf
+// ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+describe('Badge Generation', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = createTempDir('badge-test-');
+  });
+
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  test('should generate navy badge when all tests pass', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: PASSED
+    tests:
+      total: 38
+      passed: 38
+      failed: 0
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('38/38 passing');
+    expect(result.svg).toContain('#003366');
+  });
+
+  test('should generate red badge when tests fail', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: FAILED
+    tests:
+      total: 38
+      passed: 35
+      failed: 3
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('35/38 passing');
+    expect(result.svg).toContain('#E32400');
+  });
+
+  test('should generate gray badge when .taf is missing', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    // Don't create the file
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('no data');
+    expect(result.svg).toContain('#9F9F9F');
+  });
+
+  test('should generate gray badge when test_history is empty', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history: []
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('no data');
+    expect(result.svg).toContain('#9F9F9F');
+  });
+
+  test('should use latest run from multiple entries', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: FAILED
+    tests:
+      total: 10
+      passed: 7
+      failed: 3
+  - timestamp: "2026-01-02T00:00:00Z"
+    result: PASSED
+    tests:
+      total: 10
+      passed: 10
+      failed: 0
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('10/10 passing');
+    expect(result.svg).toContain('#003366');
+  });
+
+  test('should use custom label', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: PASSED
+    tests:
+      total: 5
+      passed: 5
+      failed: 0
+`);
+
+    const result = generateBadge({ tafPath, label: 'tests' });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('tests');
+    expect(result.svg).not.toContain('>TAF<');
+  });
+
+  test('should handle single test run', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: PASSED
+    tests:
+      total: 1
+      passed: 1
+      failed: 0
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('1/1 passing');
+  });
+
+  test('should handle large test counts', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: PASSED
+    tests:
+      total: 10000
+      passed: 10000
+      failed: 0
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('10000/10000 passing');
+  });
+
+  test('should handle invalid YAML gracefully', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, '{{{{ not yaml at all');
+
+    const result = generateBadge({ tafPath });
+
+    // Should either return no-data badge or error, but never throw
+    expect(result).toBeDefined();
+  });
+
+  test('should handle .taf with missing tests field', () => {
+    const tafPath = path.join(tempDir, '.taf');
+    fs.writeFileSync(tafPath, `format_version: 1.0.0
+project: test
+test_history:
+  - timestamp: "2026-01-01T00:00:00Z"
+    result: PASSED
+`);
+
+    const result = generateBadge({ tafPath });
+
+    expect(result.success).toBe(true);
+    expect(result.svg).toContain('no data');
+  });
+});

package/tests/bun-parser.test.ts

@@ -0,0 +1,173 @@
+/**
+ * Tests for Bun output parser
+ */
+
+import { parseBunOutput } from '../src/parsers/bun';
+
+describe('Bun Parser', () => {
+  describe('parseBunOutput', () => {
+    it('should parse all passing tests (minimal output)', () => {
+      const output = `
+ 173 pass
+ 0 fail
+ 612 expect() calls
+Ran 173 tests across 8 files. [4.2s]
+`;
+
+      const result = parseBunOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(173);
+      expect(result?.failed).toBe(0);
+      expect(result?.skipped).toBeUndefined();
+      expect(result?.result).toBe('PASSED');
+    });
+
+    it('should parse the grok-faf-mcp 1.4.9 shape (pass + skip + todo + fail=0)', () => {
+      const output = `
+ 232 pass
+ 1 skip
+ 1 todo
+ 0 fail
+ 848 expect() calls
+Ran 234 tests across 9 files. [21.53s]
+`;
+
+      const result = parseBunOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(234);
+      expect(result?.passed).toBe(232);
+      expect(result?.failed).toBe(0);
+      // skipped aggregates skip + todo (parity with vitest convention)
+      expect(result?.skipped).toBe(2);
+      expect(result?.result).toBe('PASSED');
+    });
+
+    it('should mark result FAILED when any tests fail', () => {
+      const output = `
+ 170 pass
+ 3 fail
+ 612 expect() calls
+Ran 173 tests across 8 files. [5.1s]
+`;
+
+      const result = parseBunOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(170);
+      expect(result?.failed).toBe(3);
+      expect(result?.result).toBe('FAILED');
+    });
+
+    it('should handle skip-only output', () => {
+      const output = `
+ 170 pass
+ 3 skip
+ 0 fail
+ 612 expect() calls
+Ran 173 tests across 8 files. [5.0s]
+`;
+
+      const result = parseBunOutput(output);
+
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(170);
+      expect(result?.skipped).toBe(3);
+      expect(result?.result).toBe('PASSED');
+    });
+
+    it('should strip ANSI color codes', () => {
+      const output =
+        '\x1b[32m 232 pass\x1b[0m\n' +
+        '\x1b[33m 1 skip\x1b[0m\n' +
+        '\x1b[33m 1 todo\x1b[0m\n' +
+        '\x1b[31m 0 fail\x1b[0m\n' +
+        ' 848 expect() calls\n' +
+        'Ran 234 tests across 9 files. [21.53s]\n';
+
+      const result = parseBunOutput(output);
+
+      expect(result?.total).toBe(234);
+      expect(result?.passed).toBe(232);
+      expect(result?.skipped).toBe(2);
+    });
+
+    it('should handle CRLF line endings', () => {
+      const output =
+        ' 173 pass\r\n 0 fail\r\nRan 173 tests across 8 files. [4.2s]\r\n';
+
+      const result = parseBunOutput(output);
+
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(173);
+    });
+
+    it('should ignore an appended jest-shim "Tests:" line (legacy ci.yml conversion)', () => {
+      // Some consumer CIs append a jest-shaped summary so the legacy jest
+      // parser could read bun output. With bun support, the appended line
+      // should be ignored — the canonical Ran-line wins.
+      const output = `
+ 232 pass
+ 1 skip
+ 1 todo
+ 0 fail
+ 848 expect() calls
+Ran 234 tests across 9 files. [21.53s]
+Tests: 232 passed, 232 total
+`;
+
+      const result = parseBunOutput(output);
+
+      // Truthful total from "Ran 234" — NOT 232 from the jest-shim line.
+      expect(result?.total).toBe(234);
+      expect(result?.passed).toBe(232);
+      expect(result?.skipped).toBe(2);
+    });
+
+    it('should return null when no "Ran N tests" line is present (non-bun output)', () => {
+      const output = `
+Test Suites: 18 passed, 18 total
+Tests:       173 passed, 173 total
+Snapshots:   0 total
+Time:        2.5s
+`;
+
+      const result = parseBunOutput(output);
+
+      // Defers to the next parser in the dispatcher chain.
+      expect(result).toBeNull();
+    });
+
+    it('should return null on empty input', () => {
+      expect(parseBunOutput('')).toBeNull();
+    });
+
+    it('should return null when "Ran 0 tests" (nothing actually ran)', () => {
+      const output = `
+ 0 pass
+ 0 fail
+Ran 0 tests across 0 files. [0.1s]
+`;
+
+      const result = parseBunOutput(output);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle singular forms gracefully (1 test)', () => {
+      const output = `
+ 1 pass
+ 0 fail
+Ran 1 test across 1 file. [0.5s]
+`;
+
+      const result = parseBunOutput(output);
+
+      expect(result?.total).toBe(1);
+      expect(result?.passed).toBe(1);
+    });
+  });
+});