xtrm-tools 2.0.0

package/project-skills/tdd-guard/reporters/test/artifacts/storybook/single-import-error.stories.js

@@ -0,0 +1,14 @@
+import { expect } from '@storybook/test'
+import { NonExistent } from './non-existent-module' // This module doesn't exist
+
+export default {
+  title: 'Calculator',
+  render: () => null, // No UI component, just testing logic
+}
+
+export const Primary = {
+  name: 'should add numbers correctly',
+  play: async () => {
+    await expect(true).toBe(true)
+  },
+}

package/project-skills/tdd-guard/reporters/test/artifacts/storybook/single-passing.stories.js

@@ -0,0 +1,15 @@
+import { expect } from '@storybook/test'
+import { Calculator } from './Calculator'
+
+export default {
+  title: 'Calculator',
+  render: () => null, // No UI component, just testing logic
+}
+
+export const Primary = {
+  name: 'should add numbers correctly',
+  play: async () => {
+    const result = Calculator.add(2, 3)
+    await expect(result).toBe(5)
+  },
+}

package/project-skills/tdd-guard/reporters/test/artifacts/vitest/single-failing.test.js

@@ -0,0 +1,7 @@
+import { describe, test, expect } from 'vitest'
+
+describe('Calculator', () => {
+  test('should add numbers correctly', () => {
+    expect(2 + 3).toBe(6)
+  })
+})

package/project-skills/tdd-guard/reporters/test/artifacts/vitest/single-import-error.test.js

@@ -0,0 +1,9 @@
+import { describe, test, expect } from 'vitest'
+import { nonExistentFunction } from './non-existent-module'
+
+describe('Calculator', () => {
+  test('should add numbers correctly', () => {
+    nonExistentFunction()
+    expect(2 + 3).toBe(5)
+  })
+})

package/project-skills/tdd-guard/reporters/test/artifacts/vitest/single-passing.test.js

@@ -0,0 +1,7 @@
+import { describe, test, expect } from 'vitest'
+
+describe('Calculator', () => {
+  test('should add numbers correctly', () => {
+    expect(2 + 3).toBe(5)
+  })
+})

package/project-skills/tdd-guard/reporters/test/factories/go.ts

@@ -0,0 +1,59 @@
+import { spawnSync, execFileSync } from 'node:child_process'
+import { join } from 'node:path'
+import { existsSync } from 'node:fs'
+import type { ReporterConfig, TestScenarios } from '../types'
+import { copyTestArtifacts } from './helpers'
+
+export function createGoReporter(): ReporterConfig {
+  // Use hardcoded absolute path for security when available, fall back to PATH for CI environments
+  const goBinary = existsSync('/usr/local/go/bin/go') ? '/usr/local/go/bin/go' : 'go'
+  const artifactDir = 'go'
+  const testScenarios = {
+    singlePassing: 'passing',
+    singleFailing: 'failing',
+    singleImportError: 'import',
+  }
+
+  return {
+    name: 'GoReporter',
+    testScenarios,
+    run: (tempDir, scenario: keyof TestScenarios) => {
+      // Copy the test module directory to temp
+      copyTestArtifacts(artifactDir, testScenarios, scenario, tempDir)
+
+      const reporterPath = join(__dirname, '../../go')
+      const binaryPath = join(tempDir, 'tdd-guard-go')
+
+      // Build the reporter binary, output to temp directory
+      spawnSync(goBinary, ['build', '-o', binaryPath, './cmd/tdd-guard-go'], {
+        cwd: reporterPath,
+        stdio: 'pipe',
+      })
+
+      // Run go test with JSON output
+      const goTestResult = spawnSync(goBinary, ['test', '-json', '.'], {
+        cwd: tempDir,
+        stdio: 'pipe',
+        encoding: 'utf8',
+      })
+      
+      // Combine stdout and stderr for processing
+      const testOutput = (goTestResult.stdout || '') + (goTestResult.stderr || '')
+      
+      // Pipe test output to our reporter
+      try {
+        execFileSync(binaryPath, ['-project-root', tempDir], {
+          cwd: tempDir,
+          input: testOutput,
+          stdio: 'pipe',
+          encoding: 'utf8',
+        })
+      } catch (error) {
+        // Return the error for test verification
+        return error as ReturnType<typeof spawnSync>
+      }
+      
+      return goTestResult
+    },
+  }
+}

package/project-skills/tdd-guard/reporters/test/factories/helpers.ts

@@ -0,0 +1,48 @@
+import { copyFileSync, mkdirSync, cpSync, statSync } from 'node:fs'
+import { join } from 'node:path'
+import type { TestScenarios } from '../types'
+
+/**
+ * Copy test artifacts from the artifacts directory to the temp directory
+ * Handles both files and directories automatically
+ */
+export function copyTestArtifacts(
+  artifactDir: string,
+  testScenarios: TestScenarios,
+  scenario: keyof TestScenarios,
+  tempDir: string,
+  options?: {
+    targetSubdir?: string // For PHPUnit which needs files in 'tests/'
+  }
+): void {
+  const artifactName = testScenarios[scenario]
+  const sourcePath = join(__dirname, '../artifacts', artifactDir, artifactName)
+
+  // Check if source is a directory or file
+  const stats = statSync(sourcePath)
+
+  if (stats.isDirectory()) {
+    // Copy entire directory contents
+    cpSync(sourcePath, tempDir, { recursive: true })
+  } else {
+    // Copy single file
+    const targetDir = options?.targetSubdir
+      ? join(tempDir, options.targetSubdir)
+      : tempDir
+
+    // Create target directory if needed
+    if (options?.targetSubdir) {
+      mkdirSync(targetDir, { recursive: true })
+    }
+
+    const destPath = join(targetDir, artifactName)
+    copyFileSync(sourcePath, destPath)
+  }
+}
+
+/**
+ * Get the path to a reporter module
+ */
+export function getReporterPath(reporterModule: string): string {
+  return join(__dirname, '../..', reporterModule).replace(/\\/g, '/')
+}

package/project-skills/tdd-guard/reporters/test/factories/index.ts

@@ -0,0 +1,7 @@
+export { createJestReporter } from './jest'
+export { createVitestReporter } from './vitest'
+export { createPhpunitReporter } from './phpunit'
+export { createPytestReporter } from './pytest'
+export { createGoReporter } from './go'
+export { createRustReporter } from './rust'
+export { createStorybookReporter } from './storybook'

package/project-skills/tdd-guard/reporters/test/factories/jest.ts

@@ -0,0 +1,51 @@
+import { spawnSync } from 'node:child_process'
+import { writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { ReporterConfig, TestScenarios } from '../types'
+import { copyTestArtifacts, getReporterPath } from './helpers'
+
+export function createJestReporter(): ReporterConfig {
+  const artifactDir = 'jest'
+  const testScenarios = {
+    singlePassing: 'single-passing.test.js',
+    singleFailing: 'single-failing.test.js',
+    singleImportError: 'single-import-error.test.js',
+  }
+
+  return {
+    name: 'JestReporter',
+    testScenarios,
+    run: (tempDir, scenario: keyof TestScenarios) => {
+      // Copy test file
+      copyTestArtifacts(artifactDir, testScenarios, scenario, tempDir)
+
+      // Write Jest config
+      writeFileSync(join(tempDir, 'jest.config.js'), createJestConfig(tempDir))
+
+      // Run Jest
+      const jestCliPath = require.resolve('jest-cli/bin/jest')
+      spawnSync(process.execPath, [jestCliPath, '--no-cache'], {
+        cwd: tempDir,
+        env: { ...process.env, CI: 'true' },
+        stdio: 'pipe',
+      })
+    },
+  }
+}
+
+function createJestConfig(tempDir: string): string {
+  const reporterPath = getReporterPath('jest/dist/index.js')
+  return `
+const path = require('path');
+
+module.exports = {
+  testMatch: ['**/*.test.js'],
+  reporters: [
+    'default',
+    ['${reporterPath}', {
+      projectRoot: '${tempDir}'
+    }]
+  ]
+};
+`
+}

package/project-skills/tdd-guard/reporters/test/factories/phpunit.ts

@@ -0,0 +1,63 @@
+import { spawnSync } from 'node:child_process'
+import { symlinkSync, writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { ReporterConfig, TestScenarios } from '../types'
+import { copyTestArtifacts } from './helpers'
+
+export function createPhpunitReporter(): ReporterConfig {
+  const artifactDir = 'phpunit'
+  const testScenarios = {
+    singlePassing: 'SinglePassingTest.php',
+    singleFailing: 'SingleFailingTest.php',
+    singleImportError: 'SingleImportErrorTest.php',
+  }
+
+  return {
+    name: 'PHPUnitReporter',
+    testScenarios,
+    run: (tempDir, scenario: keyof TestScenarios) => {
+      // Copy test file to tests subdirectory
+      copyTestArtifacts(artifactDir, testScenarios, scenario, tempDir, {
+        targetSubdir: 'tests',
+      })
+
+      // Write PHPUnit config
+      writeFileSync(join(tempDir, 'phpunit.xml'), createPhpunitConfig(tempDir))
+
+      // Create symlink to vendor directory
+      const reporterVendorPath = join(__dirname, '../../phpunit/vendor')
+      const tempVendorPath = join(tempDir, 'vendor')
+      symlinkSync(reporterVendorPath, tempVendorPath)
+
+      // Run PHPUnit
+      const phpunitPath = join(__dirname, '../../phpunit/vendor/bin/phpunit')
+      spawnSync(phpunitPath, ['-c', 'phpunit.xml'], {
+        cwd: tempDir,
+        env: { ...process.env },
+        stdio: 'pipe',
+      })
+    },
+  }
+}
+
+function createPhpunitConfig(tempDir: string): string {
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<phpunit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:noNamespaceSchemaLocation="vendor/phpunit/phpunit/phpunit.xsd"
+         bootstrap="vendor/autoload.php"
+         colors="true"
+         stopOnFailure="false">
+    <testsuites>
+        <testsuite name="Integration Tests">
+            <directory>tests</directory>
+        </testsuite>
+    </testsuites>
+    
+    <extensions>
+        <bootstrap class="TddGuard\\PHPUnit\\TddGuardExtension">
+            <parameter name="projectRoot" value="${tempDir}"/>
+        </bootstrap>
+    </extensions>
+</phpunit>
+`
+}

package/project-skills/tdd-guard/reporters/test/factories/pytest.ts

@@ -0,0 +1,41 @@
+import { spawnSync } from 'node:child_process'
+import { writeFileSync } from 'node:fs'
+import { join } from 'node:path'
+import type { ReporterConfig, TestScenarios } from '../types'
+import { copyTestArtifacts } from './helpers'
+
+export function createPytestReporter(): ReporterConfig {
+  const artifactDir = 'pytest'
+  const testScenarios = {
+    singlePassing: 'test_single_passing.py',
+    singleFailing: 'test_single_failing.py',
+    singleImportError: 'test_single_import_error.py',
+  }
+
+  return {
+    name: 'PytestReporter',
+    testScenarios,
+    run: (tempDir, scenario: keyof TestScenarios) => {
+      // Copy test file
+      copyTestArtifacts(artifactDir, testScenarios, scenario, tempDir)
+
+      // Write pytest config
+      writeFileSync(join(tempDir, 'pytest.ini'), createPytestConfig(tempDir))
+
+      // Run pytest
+      const pytestPath = join(__dirname, '../../pytest/.venv/bin/pytest')
+      const testFile = testScenarios[scenario]
+      spawnSync(pytestPath, [testFile, '-c', 'pytest.ini'], {
+        cwd: tempDir,
+        stdio: 'pipe',
+        encoding: 'utf8',
+      })
+    },
+  }
+}
+
+function createPytestConfig(tempDir: string): string {
+  return `[pytest]
+tdd_guard_project_root = ${tempDir}
+`
+}

package/project-skills/tdd-guard/reporters/test/factories/rust.ts

@@ -0,0 +1,158 @@
+// test/factories/rust.ts - Update required for the simplified Rust reporter
+
+import { spawnSync, execFileSync } from 'node:child_process'
+import { join } from 'node:path'
+import { existsSync, writeFileSync, copyFileSync } from 'node:fs'
+import type { ReporterConfig, TestScenarios } from '../types'
+import { copyTestArtifacts } from './helpers'
+
+export function createRustReporter(): ReporterConfig {
+  // Use hardcoded absolute path for security when available, fall back to PATH for CI environments
+  const rustBinary = existsSync('/usr/local/bin/cargo')
+    ? '/usr/local/bin/cargo'
+    : 'cargo'
+  const artifactDir = 'rust'
+  const testScenarios = {
+    singlePassing: 'passing',
+    singleFailing: 'failing',
+    singleImportError: 'import',
+  }
+
+  return {
+    name: 'RustReporter',
+    testScenarios,
+    run: (tempDir, scenario: keyof TestScenarios) => {
+      // Copy the test module directory to temp
+      copyTestArtifacts(artifactDir, testScenarios, scenario, tempDir)
+
+      // Clean any cached build artifacts
+      spawnSync(rustBinary, ['clean'], {
+        cwd: tempDir,
+        stdio: 'pipe',
+      })
+
+      const reporterPath = join(__dirname, '../../rust')
+      const binaryPath = join(tempDir, 'tdd-guard-rust')
+
+      // Build the reporter binary
+      const buildResult = spawnSync(rustBinary, ['build', '--release'], {
+        cwd: reporterPath,
+        stdio: 'pipe',
+      })
+      if (buildResult.status !== 0) {
+        throw new Error(`Failed to build rust reporter: ${buildResult.stderr}`)
+      }
+
+      // Copy the binary to temp dir using Node.js fs (portable, no shell dependency)
+      const sourcePath = join(reporterPath, 'target/release/tdd-guard-rust')
+      copyFileSync(sourcePath, binaryPath)
+
+      // Check if nextest is available
+      const hasNextest =
+        spawnSync(rustBinary, ['nextest', '--version'], {
+          stdio: 'pipe',
+        }).status === 0
+
+      // Run cargo test with JSON output (best effort)
+      let cargoTestResult
+
+      if (hasNextest) {
+        // Try nextest first
+        cargoTestResult = spawnSync(
+          rustBinary,
+          [
+            'nextest',
+            'run',
+            '--message-format',
+            'libtest-json',
+            '--no-fail-fast',
+          ],
+          {
+            cwd: tempDir,
+            stdio: 'pipe',
+            encoding: 'utf8',
+            env: { ...process.env, NEXTEST_EXPERIMENTAL_LIBTEST_JSON: '1' },
+          }
+        )
+      }
+
+      // Fall back to cargo test if nextest not available
+      if (!hasNextest || cargoTestResult?.status === 127) {
+        cargoTestResult = spawnSync(
+          rustBinary,
+          [
+            '+nightly',
+            'test',
+            '--no-fail-fast',
+            '--',
+            '-Z',
+            'unstable-options',
+            '--format',
+            'json',
+          ],
+          {
+            cwd: tempDir,
+            stdio: 'pipe',
+            encoding: 'utf8',
+          }
+        )
+      }
+
+      // For import error scenario, capture compilation errors
+      if (scenario === 'singleImportError') {
+        const buildTestResult = spawnSync(rustBinary, ['build', '--tests'], {
+          cwd: tempDir,
+          stdio: 'pipe',
+          encoding: 'utf8',
+        })
+
+        // Combine build stderr with any test output
+        const combinedOutput = `${buildTestResult.stderr}\n${cargoTestResult?.stdout}${cargoTestResult?.stderr}`
+
+        // Write debug output
+        const debugFile = join(tempDir, 'debug-output.txt')
+        writeFileSync(debugFile, combinedOutput)
+
+        // Process with reporter in passthrough mode
+        try {
+          execFileSync(
+            binaryPath,
+            ['--project-root', tempDir, '--passthrough'],
+            {
+              cwd: tempDir,
+              input: combinedOutput,
+              stdio: 'pipe',
+              encoding: 'utf8',
+            }
+          )
+        } catch (error) {
+          // Reporter should handle errors gracefully
+          console.debug('Reporter processing compilation error:', error)
+        }
+
+        return buildTestResult
+      }
+
+      // For normal test scenarios, process output
+      const testOutput = `${cargoTestResult.stdout}${cargoTestResult.stderr}`
+
+      // Write debug output
+      const debugFile = join(tempDir, 'debug-output.txt')
+      writeFileSync(debugFile, testOutput)
+
+      // Run reporter in passthrough mode
+      try {
+        execFileSync(binaryPath, ['--project-root', tempDir, '--passthrough'], {
+          cwd: tempDir,
+          input: testOutput,
+          stdio: 'pipe',
+          encoding: 'utf8',
+        })
+      } catch (error) {
+        console.debug('Reporter error:', error)
+      }
+
+      return cargoTestResult
+    },
+  }
+}

package/project-skills/tdd-guard/reporters/test/factories/storybook.ts

@@ -0,0 +1,198 @@
+import { spawn, spawnSync } from 'node:child_process'
+import { writeFileSync, mkdirSync, symlinkSync } from 'node:fs'
+import { join } from 'node:path'
+import getPort from 'get-port'
+import type { ReporterConfig, TestScenarios } from '../types'
+import { copyTestArtifacts, getReporterPath } from './helpers'
+
+export function createStorybookReporter(): ReporterConfig {
+  const artifactDir = 'storybook'
+  const testScenarios = {
+    singlePassing: 'single-passing.stories.js',
+    singleFailing: 'single-failing.stories.js',
+    singleImportError: 'single-import-error.stories.js',
+  }
+
+  return {
+    name: 'StorybookReporter',
+    testScenarios,
+    run: async (tempDir, scenario: keyof TestScenarios) => {
+      // Get an available port to avoid conflicts when running tests in parallel
+      const port = await getPort()
+      // Copy Calculator.js (needed by all scenarios)
+      copyTestArtifacts(
+        artifactDir,
+        { common: 'Calculator.js' },
+        'common',
+        tempDir
+      )
+
+      // Copy the specific test scenario story file
+      copyTestArtifacts(artifactDir, testScenarios, scenario, tempDir)
+
+      // Create .storybook directory and config
+      const storybookDir = join(tempDir, '.storybook')
+      mkdirSync(storybookDir, { recursive: true })
+      writeFileSync(join(storybookDir, 'main.js'), createStorybookConfig())
+
+      // Note: We don't need test-runner hooks since we're using Jest reporter to capture results
+
+      // Write test-runner config
+      writeFileSync(
+        join(tempDir, 'test-runner-jest.config.js'),
+        createTestRunnerConfig(tempDir)
+      )
+
+      // Create minimal package.json
+      writeFileSync(
+        join(tempDir, 'package.json'),
+        JSON.stringify({ name: 'storybook-test', type: 'module' })
+      )
+
+      // Create symlink to root node_modules so Vite can resolve dependencies
+      const rootNodeModules = join(__dirname, '../../../node_modules')
+      const tempNodeModules = join(tempDir, 'node_modules')
+      symlinkSync(rootNodeModules, tempNodeModules, 'dir')
+
+      // Ensure cache directory exists and is writable
+      const cacheDir = join(tempDir, '.storybook-cache')
+      mkdirSync(cacheDir, { recursive: true })
+
+      // Start Storybook dev server from root node_modules (hoisted from workspace)
+      const storybookBinPath = join(
+        __dirname,
+        '../../../node_modules/.bin/storybook'
+      )
+
+      const storybookProcess = spawn(
+        storybookBinPath,
+        ['dev', '--config-dir', '.storybook', '--port', String(port), '--ci'],
+        {
+          cwd: tempDir,
+          env: {
+            ...process.env,
+            NODE_ENV: 'development',
+            PATH: '/usr/local/bin:/usr/bin:/bin',
+            // Use custom cache directory to avoid permission issues with symlinked node_modules
+            STORYBOOK_CACHE_DIR: join(tempDir, '.storybook-cache'),
+          },
+          stdio: 'pipe',
+        }
+      )
+
+      // Wait for Storybook to be ready
+      const waitForStorybook = new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          storybookProcess.kill()
+          reject(new Error('Storybook dev server timed out'))
+        }, 60000)
+
+        storybookProcess.stdout!.on('data', (data) => {
+          const output = data.toString()
+          if (
+            output.includes('Local:') ||
+            output.includes(`http://localhost:${port}`)
+          ) {
+            clearTimeout(timeout)
+            resolve()
+          }
+        })
+
+        storybookProcess.stderr!.on('data', () => {
+          // Stderr is captured but not logged during normal operation
+        })
+
+        storybookProcess.on('error', (err) => {
+          clearTimeout(timeout)
+          reject(err)
+        })
+
+        storybookProcess.on('exit', (code, signal) => {
+          clearTimeout(timeout)
+          reject(
+            new Error(
+              `Storybook process exited early with code ${code}, signal ${signal}`
+            )
+          )
+        })
+      })
+
+      try {
+        await waitForStorybook
+
+        // Run Storybook test-runner
+        const testRunnerPath =
+          require.resolve('@storybook/test-runner/dist/test-storybook')
+        spawnSync(
+          process.execPath,
+          [
+            testRunnerPath,
+            '--url',
+            `http://localhost:${port}`,
+            '--maxWorkers=1',
+          ],
+          {
+            cwd: tempDir,
+            env: {
+              ...process.env,
+              CI: 'true',
+              NODE_ENV: 'test',
+            },
+            stdio: 'pipe',
+          }
+        )
+
+        // Vitest captures test-runner output automatically
+      } finally {
+        // Kill Storybook dev server - use SIGKILL to ensure it dies
+        storybookProcess.kill('SIGKILL')
+
+        // Wait for process to actually exit to free up port 6006
+        await new Promise<void>((resolve) => {
+          storybookProcess.once('exit', () => resolve())
+          // Fallback timeout in case exit event doesn't fire
+          setTimeout(resolve, 1000)
+        })
+      }
+    },
+  }
+}
+
+function createStorybookConfig(): string {
+  return `
+module.exports = {
+  stories: ['../*.stories.js'],
+  framework: '@storybook/react-vite',
+  core: {
+    disableTelemetry: true,
+  },
+}
+`
+}
+
+function createTestRunnerConfig(tempDir: string): string {
+  const jestReporterPath = getReporterPath('jest/dist/index.js')
+  return `
+const { getJestConfig } = require('@storybook/test-runner');
+
+module.exports = {
+  // Extend Storybook's default Jest config
+  ...getJestConfig(),
+  // Set rootDir to temp directory so Jest finds the story files
+  rootDir: '${tempDir}',
+  // Use our Jest reporter to capture test results from Storybook test-runner
+  reporters: [
+    'default',  // Keep Jest's default console output
+    ['${jestReporterPath}', { projectRoot: '${tempDir}' }]
+  ],
+  testEnvironmentOptions: {
+    'jest-playwright': {
+      browsers: ['chromium'],
+      launchOptions: {
+        headless: true,
+      },
+    },
+  },
+}
+`
+}