xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,14 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,158 +0,0 @@
-// 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

@@ -1,198 +0,0 @@
-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,
-      },
-    },
-  },
-}
-`
-}