faf-taf-git 2.0.4

package/src/index.ts

@@ -0,0 +1,131 @@
+/**
+ * faf-taf-git v2.0.0 - GitHub Actions wrapper
+ *
+ * Pre-Capture Pattern: Reads test output from file (written by previous step)
+ * Handles GitHub Actions-specific inputs/outputs
+ */
+
+import * as core from '@actions/core';
+import * as exec from '@actions/exec';
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseJestOutput } from './parsers/jest';
+import { updateTafFile } from './taf-core';
+
+/**
+ * Commit .taf file changes to git
+ */
+async function commitTafUpdate(cwd: string, message: string): Promise<void> {
+  const execOptions = { cwd };
+
+  // Configure git
+  await exec.exec('git', ['config', '--global', 'user.name', 'faf-taf-git[bot]'], execOptions);
+  await exec.exec('git', ['config', '--global', 'user.email', 'faf-taf-git[bot]@users.noreply.github.com'], execOptions);
+
+  // Stage .taf file
+  await exec.exec('git', ['add', '.taf'], execOptions);
+
+  // Check if there are changes to commit
+  const { exitCode } = await exec.getExecOutput('git', ['diff', '--cached', '--name-only'], execOptions);
+
+  if (exitCode === 0) {
+    await exec.exec('git', ['commit', '-m', message], execOptions);
+
+    // Try to push (might fail in some environments, that's ok)
+    try {
+      await exec.exec('git', ['push'], execOptions);
+    } catch (error) {
+      core.warning('Could not push changes (this is ok in some CI environments)');
+    }
+  }
+}
+
+async function run(): Promise<void> {
+  try {
+    // Get GitHub Action inputs
+    const testOutputFile = core.getInput('test-output-file', { required: true });
+    const autoCommit = core.getInput('auto-commit') !== 'false';
+    const commitMessage = core.getInput('commit-message') || 'chore(taf): update .taf receipt [skip ci]';
+    const cwd = process.cwd();
+
+    core.info(`Reading test output from: ${testOutputFile}`);
+
+    // Read test output file (written by previous CI step)
+    const testOutputPath = path.isAbsolute(testOutputFile)
+      ? testOutputFile
+      : path.join(cwd, testOutputFile);
+
+    if (!fs.existsSync(testOutputPath)) {
+      core.setFailed(`Test output file not found: ${testOutputPath}`);
+      return;
+    }
+
+    const testOutput = fs.readFileSync(testOutputPath, 'utf-8');
+    core.info(`Read ${testOutput.length} bytes from test output file`);
+
+    // Debug: Show sample of what we're parsing
+    const lines = testOutput.split('\n');
+    const testSummaryLine = lines.find(line => line.includes('Tests:'));
+    if (testSummaryLine) {
+      core.info(`Found summary line: ${testSummaryLine.substring(0, 200)}`);
+    } else {
+      core.warning('No "Tests:" summary line found in output');
+      // Show last 20 lines to help debug
+      core.info('Last 20 lines of output:');
+      lines.slice(-20).forEach((line, i) => {
+        core.info(`  ${i}: ${line.substring(0, 150)}`);
+      });
+    }
+
+    // Parse test results
+    const testResults = parseJestOutput(testOutput);
+
+    if (!testResults) {
+      core.setFailed('Could not parse test output. Ensure you are using Jest.');
+      return;
+    }
+
+    core.info(`Parsed results: ${testResults.passed}/${testResults.total} tests passing`);
+
+    // Set GitHub Action outputs
+    core.setOutput('result', testResults.result);
+    core.setOutput('passed', testResults.passed.toString());
+    core.setOutput('failed', testResults.failed.toString());
+    core.setOutput('total', testResults.total.toString());
+
+    // Check if .taf file exists
+    const tafPath = path.join(cwd, '.taf');
+    if (!fs.existsSync(tafPath)) {
+      core.setFailed('No .taf file found. Run `faf taf init` to create one.');
+      return;
+    }
+
+    // Update .taf file
+    const updated = await updateTafFile(tafPath, testResults);
+
+    if (!updated) {
+      core.setOutput('taf-updated', 'false');
+      core.setFailed('.taf file was not updated');
+      return;
+    }
+
+    core.setOutput('taf-updated', 'true');
+    core.info('✅ .taf file updated successfully');
+
+    // Commit changes if enabled
+    if (autoCommit) {
+      await commitTafUpdate(cwd, commitMessage);
+      core.info('✅ Changes committed to git');
+    }
+
+  } catch (error) {
+    if (error instanceof Error) {
+      core.setFailed(error.message);
+    } else {
+      core.setFailed('Unknown error occurred');
+    }
+  }
+}
+
+// Run the GitHub Action
+run();

package/src/parsers/jest.ts

@@ -0,0 +1,104 @@
+/**
+ * Jest output parser
+ *
+ * Extracts test counts from Jest CLI output
+ */
+
+export interface TestResults {
+  total: number;
+  passed: number;
+  failed: number;
+  skipped?: number;
+  result: 'PASSED' | 'FAILED' | 'IMPROVED' | 'DEGRADED';
+}
+
+/**
+ * Parse Jest output to extract test results
+ *
+ * Jest output formats:
+ * - "Tests: 1 failed, 172 passed, 173 total"
+ * - "Tests: 173 passed, 173 total"
+ * - "Test Suites: 2 failed, 16 passed, 18 total"
+ * - "Tests:       9 skipped, 799 passed, 808 total" (with padding)
+ */
+export function parseJestOutput(output: string): TestResults | null {
+  // Strip ANSI color codes and other control characters
+  // eslint-disable-next-line no-control-regex
+  let cleanOutput = output.replace(/\x1b\[[0-9;]*m/g, '');
+  // Also strip carriage returns and normalize line endings
+  cleanOutput = cleanOutput.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+
+  // Find the Jest test summary line
+  // CRITICAL: Must match "Tests:" line that contains "total" to avoid matching
+  // test descriptions like "Brake Tests: Critical dogfooding scenarios"
+  const testSummaryPattern = /Tests:\s+(.+?\d+\s+total)/im;
+  const testLineMatch = cleanOutput.match(testSummaryPattern);
+
+  if (!testLineMatch || !testLineMatch[1]) {
+    return null;
+  }
+
+  const testLine = testLineMatch[1];
+
+  // Extract counts using flexible patterns
+  let total = 0;
+  let passed = 0;
+  let failed = 0;
+  let skipped = 0;
+
+  // Parse numbers - use global search on the whole output near the Tests: line
+  const totalMatch = testLine.match(/(\d+)\s+total/i);
+  if (totalMatch) {
+    total = parseInt(totalMatch[1], 10);
+  }
+
+  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);
+  }
+
+  // Validate
+  if (total === 0) {
+    return null;
+  }
+
+  // Determine result
+  let result: 'PASSED' | 'FAILED' | 'IMPROVED' | 'DEGRADED' = 'PASSED';
+  if (failed > 0) {
+    result = 'FAILED';
+  }
+
+  return {
+    total,
+    passed,
+    failed,
+    skipped: skipped > 0 ? skipped : undefined,
+    result,
+  };
+}
+
+/**
+ * Example Jest outputs for testing:
+ *
+ * All passing:
+ * "Tests: 173 passed, 173 total"
+ *
+ * Some failing:
+ * "Tests: 1 failed, 172 passed, 173 total"
+ *
+ * With skipped:
+ * "Tests: 1 failed, 2 skipped, 170 passed, 173 total"
+ *
+ * With padding (CI):
+ * "Tests:       9 skipped, 799 passed, 808 total"
+ */

package/src/taf-core.ts

@@ -0,0 +1,139 @@
+/**
+ * TAF Core - Simplified for GitHub Action
+ *
+ * Pure functions for reading, parsing, and updating .taf files
+ * Derived from faf-cli TAF implementation (MCP-portable)
+ */
+
+import * as fs from 'fs';
+import * as yaml from 'yaml';
+import { TestResults } from './parsers/jest';
+
+interface TAFFile {
+  format_version?: string;
+  project?: string;
+  created?: string;
+  last_updated?: string;
+  test_history: TestRun[];
+  [key: string]: any; // Allow other fields
+}
+
+interface TestRun {
+  timestamp: string;
+  result: 'PASSED' | 'FAILED' | 'IMPROVED' | 'DEGRADED';
+  tests: {
+    total: number;
+    passed: number;
+    failed: number;
+    skipped?: number;
+  };
+  command?: string;
+  trigger?: string;
+}
+
+/**
+ * Update .taf file with new test results
+ * Creates the file if it doesn't exist
+ */
+export function updateTafFile(
+  tafPath: string,
+  testResults: TestResults
+): boolean {
+  try {
+    let taf: TAFFile;
+
+    // Check if .taf exists, create if not
+    if (fs.existsSync(tafPath)) {
+      const content = fs.readFileSync(tafPath, 'utf-8');
+      taf = parseTAF(content);
+    } else {
+      // Create new .taf file
+      const projectName = require('path').basename(require('path').dirname(tafPath));
+      taf = createTAF(projectName);
+    }
+
+    // Create test run entry
+    const run: TestRun = {
+      timestamp: new Date().toISOString(),
+      result: testResults.result,
+      tests: {
+        total: testResults.total,
+        passed: testResults.passed,
+        failed: testResults.failed,
+        skipped: testResults.skipped,
+      },
+      trigger: 'github-actions',
+    };
+
+    // Append to history
+    taf.test_history.push(run);
+
+    // Serialize and write back
+    const updated = serializeTAF(taf);
+    fs.writeFileSync(tafPath, updated, 'utf-8');
+
+    return true;
+  } catch (error) {
+    console.error('Failed to update .taf file:', error);
+    return false;
+  }
+}
+
+/**
+ * Create a new TAF file structure
+ */
+function createTAF(projectName: string): TAFFile {
+  return {
+    format_version: '1.0.0',
+    project: projectName,
+    created: new Date().toISOString(),
+    last_updated: new Date().toISOString(),
+    test_history: [],
+  };
+}
+
+/**
+ * Parse .taf file content
+ */
+function parseTAF(content: string): TAFFile {
+  // Split on document separator and take only first document
+  const lines = content.split('\n');
+  const yamlLines: string[] = [];
+
+  for (const line of lines) {
+    // Stop at document separator (but skip initial one if present)
+    if (line.trim() === '---' && yamlLines.length > 0) {
+      break;
+    }
+    // Skip initial document separator
+    if (line.trim() === '---' && yamlLines.length === 0) {
+      continue;
+    }
+    yamlLines.push(line);
+  }
+
+  const parsed = yaml.parse(yamlLines.join('\n'));
+
+  // Basic validation
+  if (!parsed || typeof parsed !== 'object') {
+    throw new Error('Invalid .taf file: not a valid YAML object');
+  }
+
+  if (!parsed.test_history || !Array.isArray(parsed.test_history)) {
+    throw new Error('Invalid .taf file: missing or invalid test_history');
+  }
+
+  return parsed as TAFFile;
+}
+
+/**
+ * Serialize TAF object back to YAML
+ * Uses yaml library to maintain existing format
+ */
+function serializeTAF(taf: TAFFile): string {
+  // Update last_updated timestamp
+  taf.last_updated = new Date().toISOString();
+
+  // Use yaml.stringify to preserve format
+  return yaml.stringify(taf);
+}

package/test-mcp.ts

@@ -0,0 +1,83 @@
+/**
+ * Test action with claude-faf-mcp repository
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseJestOutput } from './src/parsers/jest';
+import { updateTafFile } from './src/taf-core';
+
+async function testMCP() {
+  console.log('Testing action with claude-faf-mcp repo...\n');
+
+  // Simulate Jest output (based on typical MCP test output)
+  const jestOutput = `
+PASS tests/tools.test.ts
+PASS tests/validation.test.ts
+
+Test Suites: 2 passed, 2 total
+Tests:       15 passed, 15 total
+Snapshots:   0 total
+Time:        1.234 s
+`;
+
+  console.log('1. Parsing Jest output...');
+  const testResults = parseJestOutput(jestOutput);
+
+  if (!testResults) {
+    console.error('❌ Failed to parse Jest output');
+    process.exit(1);
+  }
+
+  console.log('✅ Parsed successfully:');
+  console.log(`   - Total: ${testResults.total}`);
+  console.log(`   - Passed: ${testResults.passed}`);
+  console.log(`   - Failed: ${testResults.failed}`);
+  console.log(`   - Result: ${testResults.result}\n`);
+
+  // Test with MCP .taf file
+  const tafPath = path.join('/Users/wolfejam/FAF/claude-faf-mcp', '.taf');
+
+  console.log('2. Checking .taf file...');
+  if (!fs.existsSync(tafPath)) {
+    console.error('❌ No .taf file found at:', tafPath);
+    process.exit(1);
+  }
+  console.log('✅ Found .taf file\n');
+
+  console.log('3. Reading current .taf file...');
+  const beforeContent = fs.readFileSync(tafPath, 'utf-8');
+  const beforeLines = beforeContent.split('\n').filter(line => line.includes('timestamp')).length;
+  console.log(`✅ Current test runs: ${beforeLines}\n`);
+
+  console.log('4. Updating .taf file...');
+  const updated = await updateTafFile(tafPath, testResults);
+
+  if (!updated) {
+    console.error('❌ Failed to update .taf file');
+    process.exit(1);
+  }
+  console.log('✅ .taf file updated\n');
+
+  console.log('5. Verifying update...');
+  const afterContent = fs.readFileSync(tafPath, 'utf-8');
+  const afterLines = afterContent.split('\n').filter(line => line.includes('timestamp')).length;
+  console.log(`✅ Test runs after update: ${afterLines}`);
+
+  if (afterLines !== beforeLines + 1) {
+    console.error('❌ Expected one additional run');
+    process.exit(1);
+  }
+
+  console.log('\n✅ MCP test PASSED');
+  console.log('\nThe action successfully:');
+  console.log('  - Parsed Jest output (15/15 tests)');
+  console.log('  - Updated .taf file');
+  console.log('  - Added new test run entry');
+  console.log('  - Maintained proper format');
+}
+
+testMCP().catch(error => {
+  console.error('❌ Test failed:', error);
+  process.exit(1);
+});

package/test-standalone.ts

@@ -0,0 +1,87 @@
+/**
+ * Standalone test script to simulate the action
+ * Tests the action logic without GitHub Actions environment
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseJestOutput } from './src/parsers/jest';
+import { updateTafFile } from './src/taf-core';
+
+async function testAction() {
+  console.log('Starting standalone action test...\n');
+
+  // Simulate Jest output from faf-cli
+  const jestOutput = `
+PASS src/commands/taf-init.test.ts
+PASS src/commands/taf-log.test.ts
+PASS src/commands/taf-validate.test.ts
+PASS src/commands/taf-stats.test.ts
+
+Test Suites: 18 passed, 18 total
+Tests:       173 passed, 173 total
+Snapshots:   0 total
+Time:        2.512 s
+Ran all test suites.
+`;
+
+  console.log('1. Parsing Jest output...');
+  const testResults = parseJestOutput(jestOutput);
+
+  if (!testResults) {
+    console.error('❌ Failed to parse Jest output');
+    process.exit(1);
+  }
+
+  console.log('✅ Parsed successfully:');
+  console.log(`   - Total: ${testResults.total}`);
+  console.log(`   - Passed: ${testResults.passed}`);
+  console.log(`   - Failed: ${testResults.failed}`);
+  console.log(`   - Result: ${testResults.result}\n`);
+
+  // Test with faf-cli .taf file
+  const tafPath = path.join('/Users/wolfejam/FAF/cli', '.taf');
+
+  console.log('2. Checking .taf file...');
+  if (!fs.existsSync(tafPath)) {
+    console.error('❌ No .taf file found at:', tafPath);
+    process.exit(1);
+  }
+  console.log('✅ Found .taf file\n');
+
+  console.log('3. Reading current .taf file...');
+  const beforeContent = fs.readFileSync(tafPath, 'utf-8');
+  const beforeLines = beforeContent.split('\n').filter(line => line.includes('timestamp')).length;
+  console.log(`✅ Current test runs: ${beforeLines}\n`);
+
+  console.log('4. Updating .taf file...');
+  const updated = await updateTafFile(tafPath, testResults);
+
+  if (!updated) {
+    console.error('❌ Failed to update .taf file');
+    process.exit(1);
+  }
+  console.log('✅ .taf file updated\n');
+
+  console.log('5. Verifying update...');
+  const afterContent = fs.readFileSync(tafPath, 'utf-8');
+  const afterLines = afterContent.split('\n').filter(line => line.includes('timestamp')).length;
+  console.log(`✅ Test runs after update: ${afterLines}`);
+
+  if (afterLines !== beforeLines + 1) {
+    console.error('❌ Expected one additional run');
+    process.exit(1);
+  }
+
+  console.log('\n✅ Standalone test PASSED');
+  console.log('\nThe action successfully:');
+  console.log('  - Parsed Jest output (173/173 tests)');
+  console.log('  - Updated .taf file');
+  console.log('  - Added new test run entry');
+  console.log('  - Maintained proper format');
+}
+
+testAction().catch(error => {
+  console.error('❌ Test failed:', error);
+  process.exit(1);
+});

package/tests/jest-parser.test.ts

@@ -0,0 +1,122 @@
+/**
+ * Tests for Jest output parser
+ */
+
+import { parseJestOutput } from '../src/parsers/jest';
+
+describe('Jest Parser', () => {
+  describe('parseJestOutput', () => {
+    it('should parse all passing tests', () => {
+      const output = `
+Test Suites: 18 passed, 18 total
+Tests:       173 passed, 173 total
+Snapshots:   0 total
+Time:        2.5s
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(173);
+      expect(result?.failed).toBe(0);
+      expect(result?.result).toBe('PASSED');
+    });
+
+    it('should parse with failed tests', () => {
+      const output = `
+Test Suites: 1 failed, 17 passed, 18 total
+Tests:       1 failed, 172 passed, 173 total
+Snapshots:   0 total
+Time:        2.5s
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(172);
+      expect(result?.failed).toBe(1);
+      expect(result?.result).toBe('FAILED');
+    });
+
+    it('should parse with skipped tests', () => {
+      const output = `
+Test Suites: 18 passed, 18 total
+Tests:       2 skipped, 171 passed, 173 total
+Snapshots:   0 total
+Time:        2.5s
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(171);
+      expect(result?.failed).toBe(0);
+      expect(result?.skipped).toBe(2);
+      expect(result?.result).toBe('PASSED');
+    });
+
+    it('should parse with mixed results', () => {
+      const output = `
+Test Suites: 2 failed, 16 passed, 18 total
+Tests:       5 failed, 3 skipped, 165 passed, 173 total
+Snapshots:   0 total
+Time:        2.5s
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(165);
+      expect(result?.failed).toBe(5);
+      expect(result?.skipped).toBe(3);
+      expect(result?.result).toBe('FAILED');
+    });
+
+    it('should handle output without test line', () => {
+      const output = `
+Some random output
+No test results here
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle malformed output', () => {
+      const output = `
+Tests: invalid data
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).toBeNull();
+    });
+
+    it('should handle real CLI output with colors', () => {
+      const output = `
+PASS src/commands/taf-init.test.ts
+PASS src/commands/taf-log.test.ts
+PASS src/commands/taf-validate.test.ts
+
+Test Suites: 18 passed, 18 total
+Tests:       173 passed, 173 total
+Snapshots:   0 total
+Time:        2.512 s
+Ran all test suites.
+`;
+
+      const result = parseJestOutput(output);
+
+      expect(result).not.toBeNull();
+      expect(result?.total).toBe(173);
+      expect(result?.passed).toBe(173);
+      expect(result?.failed).toBe(0);
+      expect(result?.result).toBe('PASSED');
+    });
+  });
+});