faf-taf-git 2.0.4 → 2.2.1

package/src/cli.ts

@@ -1,20 +1,20 @@
 #!/usr/bin/env node
 /**
- * faf-taf-git - Standalone CLI for TAF operations
+ * faf-taf-git - The Git-Native Receipt Printer
  *
- * Platform-agnostic core that works in ANY CI/CD environment
- * Can be used standalone or as a library by wrappers
+ * v2.x CLI: reads test output from file (pre-capture pattern)
+ * Platform-agnostic - works in ANY CI/CD environment or locally
  */
 
-import * as exec from '@actions/exec';
+import { execSync } from 'child_process';
 import * as fs from 'fs';
-import * as os from 'os';
 import * as path from 'path';
-import { parseJestOutput } from './parsers/jest';
+import { parseTestOutput } from './parsers';
 import { updateTafFile } from './taf-core';
+import { generateBadge } from './badge';
 
 export interface CLIOptions {
-  command?: string;
+  file?: string;
   autoCommit?: boolean;
   commitMessage?: string;
   cwd?: string;
@@ -35,12 +35,11 @@ export interface CLIResult {
 }
 
 /**
- * Main CLI function - platform-agnostic
- * Can be called from GitHub Actions, GitLab CI, or standalone
+ * Main CLI function - reads test output from file
  */
 export async function runTafGit(options: CLIOptions = {}): Promise<CLIResult> {
   const {
-    command = 'npm test',
+    file,
     autoCommit = false,
     commitMessage = 'chore: update .taf with test results',
     cwd = process.cwd(),
@@ -49,125 +48,40 @@ export async function runTafGit(options: CLIOptions = {}): Promise<CLIResult> {
   } = options;
 
   try {
-    if (verbose) console.log(`Running test command: ${command}`);
-
-    // Run tests and capture output using @actions/exec
-    let output = '';
-    let exitCode = 0;
-
-    try {
-      // Parse command into executable and args
-      // For "npm test" -> ["npm", "test"]
-      const commandParts = command.split(' ');
-      const executable = commandParts[0];
-      const args = commandParts.slice(1);
-
-      const options: exec.ExecOptions = {
-        cwd,
-        silent: false, // Show output in logs
-        ignoreReturnCode: true // Don't throw on non-zero exit
+    if (!file) {
+      return {
+        success: false,
+        tafUpdated: false,
+        error: 'No test output file specified. Use --file <path>.\nExample: npm test 2>&1 | tee test-output.txt && npx faf-taf-git --file test-output.txt',
       };
+    }
 
-      // --- [START NUCLEAR CANARY] ---
-      // Use getExecOutput to capture stdout/stderr
-      const result = await exec.getExecOutput(executable, args, options);
-
-      // THE NUCLEAR CANARY: Write directly to disk, bypassing stdout/stderr streams
-      // Write to MULTIPLE locations to ensure we find it!
-      const canaryContent = [
-        `=========================================`,
-        `TAF DEBUG CANARY REPORT`,
-        `Timestamp: ${new Date().toISOString()}`,
-        `CWD: ${cwd}`,
-        `Process CWD: ${process.cwd()}`,
-        `=========================================`,
-        `Exit Code: ${result.exitCode}`,
-        `Stdout Length: ${result.stdout.length}`,
-        `Stderr Length: ${result.stderr.length}`,
-        `-----------------------------------------`,
-        `STDOUT PREVIEW (First 500 chars):`,
-        `${result.stdout.substring(0, 500)}`,
-        `-----------------------------------------`,
-        `STDERR PREVIEW (First 500 chars):`,
-        `${result.stderr.substring(0, 500)}`,
-        `=========================================`
-      ].join('\n');
-
-      try {
-        // Try multiple locations!
-        const locations = [
-          path.join(cwd, 'TAF_DEBUG_CANARY.txt'),           // Original cwd
-          path.join(process.cwd(), 'TAF_DEBUG_CANARY.txt'), // Process cwd
-          path.join(os.tmpdir(), 'TAF_DEBUG_CANARY.txt'),   // OS temp directory
-          'TAF_DEBUG_CANARY.txt'                              // Current directory
-        ];
-
-        let writeSuccess = false;
-        for (const loc of locations) {
-          try {
-            fs.writeFileSync(loc, canaryContent);
-            writeSuccess = true;
-          } catch (e) {
-            // Try next location
-          }
-        }
-
-        if (!writeSuccess) {
-          throw new Error('CRITICAL: Failed to write canary to ANY location!');
-        }
-      } catch (fsError: any) {
-        // If we can't write to disk, we are truly doomed
-        throw new Error(`CRITICAL: Failed to write canary file: ${fsError.message}`);
-      }
+    // Resolve file path
+    const filePath = path.isAbsolute(file) ? file : path.join(cwd, file);
 
-      // Continue with original logic
-      exitCode = result.exitCode;
-      output = result.stdout + result.stderr;
-      // --- [END NUCLEAR CANARY] ---
-    } catch (error: any) {
-      exitCode = 1;
-      if (verbose) {
-        logger(`Test command failed with error: ${error.message}`);
-        logger(`Captured output length: ${output.length} bytes`);
-      }
+    if (!fs.existsSync(filePath)) {
+      return {
+        success: false,
+        tafUpdated: false,
+        error: `Test output file not found: ${filePath}`,
+      };
     }
 
-    // Debug: Write entire output to file for inspection
-    if (verbose) {
-      try {
-        const fs = require('fs');
-        const debugPath = path.join(os.tmpdir(), 'taf-debug-output.txt');
-        fs.writeFileSync(debugPath, output);
-        logger(`DEBUG: Wrote ${output.length} bytes to ${debugPath}`);
-        const lines = output.split('\n');
-        const testLine = lines.find(l => l.includes('Tests:'));
-        logger(`DEBUG: Output has ${lines.length} lines, Found "Tests:": ${testLine ? 'YES' : 'NO'}`);
-        if (testLine) {
-          logger(`DEBUG: Tests line: "${testLine}"`);
-        } else {
-          logger(`DEBUG: Last 10 lines of output:`);
-          lines.slice(-10).forEach((line, i) => {
-            logger(`  ${i}: ${line.substring(0, 100)}`);
-          });
-        }
-      } catch (err) {
-        logger(`DEBUG: Error writing debug file: ${err}`);
-      }
-    }
+    const output = fs.readFileSync(filePath, 'utf-8');
+    if (verbose) logger(`Read ${output.length} bytes from ${filePath}`);
 
     // Parse test output
-    const testResults = parseJestOutput(output);
+    const testResults = parseTestOutput(output);
 
     if (!testResults) {
       if (verbose) {
-        logger(`DEBUG: Parser returned null`);
-        logger(`DEBUG: Output sample (first 500 chars): ${output.slice(0, 500)}`);
-        logger(`DEBUG: Output sample (last 500 chars): ${output.slice(-500)}`);
+        logger(`Parser returned null`);
+        logger(`Output sample (first 500 chars): ${output.slice(0, 500)}`);
       }
       return {
         success: false,
         tafUpdated: false,
-        error: 'Could not parse test output. Ensure you are using Jest.',
+        error: 'Could not parse test output. Supported: Jest, Vitest.',
       };
     }
 
@@ -195,12 +109,12 @@ export async function runTafGit(options: CLIOptions = {}): Promise<CLIResult> {
     const updated = await updateTafFile(tafPath, testResults);
 
     if (updated) {
-      if (verbose) logger('✅ .taf file updated successfully');
+      if (verbose) logger('.taf file updated successfully');
 
       // Commit changes if enabled
       if (autoCommit) {
-        await commitTafUpdate(cwd, commitMessage, verbose, logger);
-        if (verbose) logger('✅ Changes committed to git');
+        commitTafUpdate(cwd, commitMessage, verbose, logger);
+        if (verbose) logger('Changes committed to git');
       }
 
       return {
@@ -236,96 +150,115 @@ export async function runTafGit(options: CLIOptions = {}): Promise<CLIResult> {
 }
 
 /**
- * Commit .taf file changes to git (platform-agnostic)
+ * Commit .taf file changes to git
  */
-async function commitTafUpdate(cwd: string, message: string, verbose: boolean, logger: (msg: string) => void = console.log): Promise<void> {
+function commitTafUpdate(cwd: string, message: string, verbose: boolean, logger: (msg: string) => void = console.log): void {
   try {
-    const execOptions: exec.ExecOptions = { cwd };
-
-    // Configure git if needed
-    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
-    let diffOutput = '';
-    const diffOptions: exec.ExecOptions = {
-      cwd,
-      listeners: {
-        stdout: (data: Buffer) => {
-          diffOutput += data.toString();
-        }
-      }
-    };
-    await exec.exec('git', ['diff', '--cached', '--name-only'], diffOptions);
-
-    if (diffOutput.trim().length > 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) {
-        if (verbose) {
-          logger('Could not push changes (this is ok in some CI environments)');
-        }
-      }
-    } else {
+    const opts = { cwd, stdio: 'pipe' as const };
+
+    execSync('git add .taf', opts);
+
+    const diff = execSync('git diff --cached --name-only', opts).toString().trim();
+    if (diff.length === 0) {
       if (verbose) logger('No changes to commit');
+      return;
     }
-  } catch (error) {
-    if (verbose) {
-      logger(`Error committing changes: ${error}`);
+
+    execSync(`git commit -m "${message}"`, opts);
+
+    try {
+      execSync('git push', opts);
+    } catch {
+      if (verbose) logger('Could not push changes (this is ok in some CI environments)');
     }
+  } catch (error) {
+    if (verbose) logger(`Error committing changes: ${error}`);
     throw error;
   }
 }
 
 /**
- * CLI entry point - parse args and run
+ * Handle the 'badge' subcommand
  */
-async function main() {
-  const args = process.argv.slice(2);
+function handleBadgeCommand(args: string[]): void {
+  if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+faf-taf-git badge - Generate SVG badge from .taf history
 
-  const options: CLIOptions = {
-    verbose: args.includes('--verbose') || args.includes('-v'),
-  };
+USAGE:
+  npx faf-taf-git badge [OPTIONS]
 
-  // Parse command flag
-  const commandIndex = args.indexOf('--command');
-  if (commandIndex !== -1 && args[commandIndex + 1]) {
-    options.command = args[commandIndex + 1];
+OPTIONS:
+  --output <path>     Write SVG to file (default: stdout)
+  --label <text>      Badge label (default: TAF)
+  --taf <path>        Path to .taf file (default: .taf)
+  --help, -h          Show this help
+`);
+    process.exit(0);
   }
 
-  // Parse auto-commit flag
-  if (args.includes('--commit')) {
-    options.autoCommit = true;
+  // Parse --output
+  let outputPath: string | undefined;
+  const outputIndex = args.indexOf('--output');
+  if (outputIndex !== -1 && args[outputIndex + 1]) {
+    outputPath = args[outputIndex + 1];
   }
 
-  // Parse commit message
-  const messageIndex = args.indexOf('--message');
-  if (messageIndex !== -1 && args[messageIndex + 1]) {
-    options.commitMessage = args[messageIndex + 1];
+  // Parse --label
+  let label: string | undefined;
+  const labelIndex = args.indexOf('--label');
+  if (labelIndex !== -1 && args[labelIndex + 1]) {
+    label = args[labelIndex + 1];
   }
 
-  // Parse working directory
-  const cwdIndex = args.indexOf('--cwd');
-  if (cwdIndex !== -1 && args[cwdIndex + 1]) {
-    options.cwd = args[cwdIndex + 1];
+  // Parse --taf
+  let tafPath: string | undefined;
+  const tafIndex = args.indexOf('--taf');
+  if (tafIndex !== -1 && args[tafIndex + 1]) {
+    tafPath = args[tafIndex + 1];
+  }
+
+  const result = generateBadge({ tafPath, label });
+
+  if (!result.success || !result.svg) {
+    console.error(`Error: ${result.error || 'Failed to generate badge'}`);
+    process.exit(1);
+  }
+
+  if (outputPath) {
+    fs.writeFileSync(outputPath, result.svg, 'utf-8');
+    console.log(`Badge written to ${outputPath}`);
+  } else {
+    process.stdout.write(result.svg);
+  }
+}
+
+/**
+ * CLI entry point
+ */
+async function main() {
+  const args = process.argv.slice(2);
+
+  // Subcommand: badge
+  if (args[0] === 'badge') {
+    handleBadgeCommand(args.slice(1));
+    return;
   }
 
   // Show help
   if (args.includes('--help') || args.includes('-h')) {
     console.log(`
-faf-taf-git - Platform-agnostic TAF updater
+faf-taf-git - The Git-Native Receipt Printer
 
 USAGE:
-  npx faf-taf-git [OPTIONS]
+  npm test 2>&1 | tee test-output.txt
+  npx faf-taf-git --file test-output.txt [OPTIONS]
+
+COMMANDS:
+  badge               Generate a shields.io-style SVG badge from .taf
 
 OPTIONS:
-  --command <cmd>     Test command to run (default: npm test)
+  --file <path>       Path to test output file (required)
   --commit            Auto-commit .taf changes to git
   --message <msg>     Custom commit message
   --cwd <dir>         Working directory (default: current)
@@ -333,29 +266,23 @@ OPTIONS:
   --help, -h          Show this help
 
 EXAMPLES:
-  # Run tests and update .taf
-  npx faf-taf-git
-
-  # Custom test command
-  npx faf-taf-git --command "npm run test:unit"
+  # Run tests, capture output, generate receipt
+  npm test 2>&1 | tee test-output.txt
+  npx faf-taf-git --file test-output.txt
 
   # Auto-commit changes
-  npx faf-taf-git --commit
+  npx faf-taf-git --file test-output.txt --commit
 
   # Custom commit message
-  npx faf-taf-git --commit --message "test: update TAF"
+  npx faf-taf-git --file test-output.txt --commit --message "test: update TAF"
 
-  # Verbose mode
-  npx faf-taf-git --verbose
+  # Generate badge
+  npx faf-taf-git badge --output badge.svg
 
 PLATFORM SUPPORT:
-  ✅ GitHub Actions
-  ✅ GitLab CI
-  ✅ Bitbucket Pipelines
-  ✅ Jenkins
-  ✅ CircleCI
-  ✅ Local development
-  ✅ Any CI/CD that runs Node.js
+  Works in ANY CI/CD that runs Node.js:
+  GitHub Actions, GitLab CI, Jenkins, CircleCI,
+  Bitbucket Pipelines, Azure Pipelines, local dev
 
 LEARN MORE:
   https://github.com/Wolfe-Jam/faf-taf-git
@@ -363,20 +290,47 @@ LEARN MORE:
     process.exit(0);
   }
 
+  const options: CLIOptions = {
+    verbose: args.includes('--verbose') || args.includes('-v'),
+  };
+
+  // Parse --file
+  const fileIndex = args.indexOf('--file');
+  if (fileIndex !== -1 && args[fileIndex + 1]) {
+    options.file = args[fileIndex + 1];
+  }
+
+  // Parse auto-commit flag
+  if (args.includes('--commit')) {
+    options.autoCommit = true;
+  }
+
+  // Parse commit message
+  const messageIndex = args.indexOf('--message');
+  if (messageIndex !== -1 && args[messageIndex + 1]) {
+    options.commitMessage = args[messageIndex + 1];
+  }
+
+  // Parse working directory
+  const cwdIndex = args.indexOf('--cwd');
+  if (cwdIndex !== -1 && args[cwdIndex + 1]) {
+    options.cwd = args[cwdIndex + 1];
+  }
+
   // Run the tool
   const result = await runTafGit(options);
 
   if (result.success) {
     if (result.testResults) {
-      console.log(`✅ Tests: ${result.testResults.passed}/${result.testResults.total} passing`);
-      console.log(`✅ Result: ${result.testResults.result}`);
+      console.log(`Tests: ${result.testResults.passed}/${result.testResults.total} passing`);
+      console.log(`Result: ${result.testResults.result}`);
     }
     if (result.tafUpdated) {
-      console.log('✅ .taf file updated');
+      console.log('.taf file updated');
     }
     process.exit(0);
   } else {
-    console.error(`❌ Error: ${result.error}`);
+    console.error(`Error: ${result.error}`);
     if (result.testResults) {
       console.log(`Tests: ${result.testResults.passed}/${result.testResults.total} passing`);
     }

package/src/index.ts

@@ -9,13 +9,68 @@ 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 { parseTestOutput } from './parsers';
 import { updateTafFile } from './taf-core';
 
 /**
- * Commit .taf file changes to git
+ * Switch to a dedicated target branch for TAF receipts.
+ * Creates the branch as an orphan on first run, seeded with existing .taf.
  */
-async function commitTafUpdate(cwd: string, message: string): Promise<void> {
+async function switchToTargetBranch(cwd: string, targetBranch: string, tafSeed: string | null): Promise<void> {
+  const execOptions = { cwd };
+
+  // Configure git (needed before any git operations)
+  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);
+
+  // Check if target branch exists on remote
+  const { exitCode } = await exec.getExecOutput(
+    'git', ['ls-remote', '--exit-code', 'origin', targetBranch],
+    { ...execOptions, ignoreReturnCode: true }
+  );
+
+  if (exitCode === 0) {
+    // Branch exists — fetch and checkout
+    // Stash any working tree changes (e.g. dist/ from build step) to allow clean checkout
+    await exec.exec('git', ['stash', '--include-untracked'], execOptions);
+    await exec.exec('git', ['fetch', 'origin', targetBranch], execOptions);
+    await exec.exec('git', ['checkout', targetBranch], execOptions);
+    core.info(`Switched to existing branch: ${targetBranch}`);
+  } else {
+    // Branch doesn't exist — create orphan
+    await exec.exec('git', ['checkout', '--orphan', targetBranch], execOptions);
+    await exec.getExecOutput('git', ['rm', '-rf', '.'], { ...execOptions, ignoreReturnCode: true });
+
+    const tafPath = path.join(cwd, '.taf');
+
+    if (tafSeed) {
+      // Seed with existing .taf from source branch
+      fs.writeFileSync(tafPath, tafSeed, 'utf-8');
+      core.info(`Seeded ${targetBranch} with existing .taf data`);
+    } else {
+      // No seed — create minimal valid YAML so updateTafFile can populate test_history.
+      // Without this, `git add .taf` fails with exit 128 (pathspec did not match)
+      // when consumer repo has no .taf on source branch.
+      const projectName = path.basename(cwd);
+      const minimal =
+        `format_version: 1.0.0\n` +
+        `project: ${projectName}\n` +
+        `created: ${new Date().toISOString()}\n` +
+        `test_history: []\n`;
+      fs.writeFileSync(tafPath, minimal, 'utf-8');
+      core.info(`Created empty .taf for new ${targetBranch} branch (no seed)`);
+    }
+
+    await exec.exec('git', ['add', '.taf'], execOptions);
+    await exec.exec('git', ['commit', '-m', `chore(taf): initialize ${targetBranch} branch [skip ci]`], execOptions);
+    core.info(`Created new branch: ${targetBranch}`);
+  }
+}
+
+/**
+ * Commit .taf file changes to git and push
+ */
+async function commitTafUpdate(cwd: string, message: string, targetBranch?: string): Promise<void> {
   const execOptions = { cwd };
 
   // Configure git
@@ -31,9 +86,10 @@ async function commitTafUpdate(cwd: string, message: string): Promise<void> {
   if (exitCode === 0) {
     await exec.exec('git', ['commit', '-m', message], execOptions);
 
-    // Try to push (might fail in some environments, that's ok)
+    // Push to target branch or current branch
+    const pushArgs = targetBranch ? ['push', 'origin', targetBranch] : ['push'];
     try {
-      await exec.exec('git', ['push'], execOptions);
+      await exec.exec('git', pushArgs, execOptions);
     } catch (error) {
       core.warning('Could not push changes (this is ok in some CI environments)');
     }
@@ -46,6 +102,7 @@ async function run(): Promise<void> {
     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 targetBranch = core.getInput('target-branch') || '';
     const cwd = process.cwd();
 
     core.info(`Reading test output from: ${testOutputFile}`);
@@ -78,10 +135,10 @@ async function run(): Promise<void> {
     }
 
     // Parse test results
-    const testResults = parseJestOutput(testOutput);
+    const testResults = parseTestOutput(testOutput);
 
     if (!testResults) {
-      core.setFailed('Could not parse test output. Ensure you are using Jest.');
+      core.setFailed('Could not parse test output. Supported: Jest, Vitest.');
       return;
     }
 
@@ -93,8 +150,20 @@ async function run(): Promise<void> {
     core.setOutput('failed', testResults.failed.toString());
     core.setOutput('total', testResults.total.toString());
 
-    // Check if .taf file exists
+    // If target-branch is set, save .taf seed and switch branches
+    let tafSeed: string | null = null;
     const tafPath = path.join(cwd, '.taf');
+
+    if (targetBranch) {
+      // Save existing .taf from source branch as seed for first-run
+      if (fs.existsSync(tafPath)) {
+        tafSeed = fs.readFileSync(tafPath, 'utf-8');
+      }
+      core.info(`Switching to target branch: ${targetBranch}`);
+      await switchToTargetBranch(cwd, targetBranch, tafSeed);
+    }
+
+    // Check if .taf file exists (on current or target branch)
     if (!fs.existsSync(tafPath)) {
       core.setFailed('No .taf file found. Run `faf taf init` to create one.');
       return;
@@ -114,8 +183,8 @@ async function run(): Promise<void> {
 
     // Commit changes if enabled
     if (autoCommit) {
-      await commitTafUpdate(cwd, commitMessage);
-      core.info('✅ Changes committed to git');
+      await commitTafUpdate(cwd, commitMessage, targetBranch || undefined);
+      core.info(`✅ Changes committed${targetBranch ? ` to ${targetBranch}` : ''}`);
     }
 
   } catch (error) {