xtrm-tools 2.2.0 → 2.4.0

package/project-skills/tdd-guard/reporters/test/types.ts

@@ -1,28 +0,0 @@
-export interface TestScenarios {
-  singlePassing: string
-  singleFailing: string
-  singleImportError: string
-}
-
-export interface ReporterConfig {
-  name: string
-  testScenarios: TestScenarios
-  run: (tempDir: string, scenario: keyof TestScenarios) => void | Promise<void>
-}
-
-export interface TestResultData {
-  testModules: Array<{
-    moduleId: string
-    tests: Array<{
-      name: string
-      fullName: string
-      state: string
-      errors?: Array<{
-        message: string
-        expected?: string
-        actual?: string
-      }>
-    }>
-  }>
-  reason: string
-}

package/project-skills/tdd-guard/reporters/vitest/README.md

@@ -1,64 +0,0 @@
-# TDD Guard Vitest Reporter
-
-Vitest reporter that captures test results for TDD Guard validation.
-
-## Requirements
-
-- Node.js 18+
-- Vitest 3.2.0+
-- [TDD Guard](https://github.com/nizos/tdd-guard) installed globally
-
-## Installation
-
-```bash
-npm install --save-dev tdd-guard-vitest
-```
-
-## Configuration
-
-### Vitest Configuration
-
-Add the reporter to your `vitest.config.ts`:
-
-```typescript
-import { defineConfig } from 'vitest/config'
-import { VitestReporter } from 'tdd-guard-vitest'
-
-export default defineConfig({
-  test: {
-    reporters: ['default', new VitestReporter()],
-  },
-})
-```
-
-### Workspace/Monorepo Configuration
-
-For workspaces or monorepos, pass the project root path to the reporter:
-
-```typescript
-// vitest.config.ts in project root
-import { defineConfig } from 'vitest/config'
-import { VitestReporter } from 'tdd-guard-vitest'
-import path from 'path'
-
-export default defineConfig({
-  test: {
-    reporters: ['default', new VitestReporter(path.resolve(__dirname))],
-  },
-})
-```
-
-If your vitest config is in a workspace subdirectory, pass the absolute path to your project root:
-
-```typescript
-new VitestReporter('/Users/username/projects/my-app')
-```
-
-## More Information
-
-- Test results are saved to `.claude/tdd-guard/data/test.json`
-- See [TDD Guard documentation](https://github.com/nizos/tdd-guard) for complete setup
-
-## License
-
-MIT

package/project-skills/tdd-guard/reporters/vitest/package.json

@@ -1,35 +0,0 @@
-{
-  "name": "tdd-guard-vitest",
-  "version": "0.1.6",
-  "description": "Vitest reporter for TDD Guard",
-  "author": "Nizar Selander",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/nizos/tdd-guard.git",
-    "directory": "reporters/vitest"
-  },
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "!dist/*.tsbuildinfo",
-    "!dist/*.test-data.*"
-  ],
-  "scripts": {
-    "build": "tsc --build",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "tdd-guard": "^1.1.0"
-  },
-  "peerDependencies": {
-    "vitest": ">=3.2.4"
-  },
-  "devDependencies": {
-    "@types/node": "^24.1.0",
-    "typescript": "^5.8.3",
-    "vitest": "^3.2.4"
-  }
-}

package/project-skills/tdd-guard/reporters/vitest/src/VitestReporter.test-data.ts

@@ -1,85 +0,0 @@
-import type { TestModule, TestCase, TestResult } from 'vitest/node'
-import type { SerializedError } from '@vitest/utils'
-
-const DEFAULT_MODULE_ID = '/test/example.test.ts'
-const DEFAULT_TEST_NAME = 'should pass'
-const DEFAULT_TEST_FULL_NAME = 'Example Suite > should pass'
-
-// Helper to create a valid TestResult for a given state
-export function createTestResult(state: TestResult['state']): TestResult {
-  switch (state) {
-    case 'failed':
-      return { state: 'failed', errors: [] }
-    case 'passed':
-      return { state: 'passed', errors: undefined }
-    case 'skipped':
-      return { state: 'skipped', errors: undefined, note: undefined }
-    case 'pending':
-      return { state: 'pending', errors: undefined }
-  }
-}
-
-// Creates a minimal TestModule mock for testing
-function createTestModule(props: {
-  moduleId: string
-  errors?: () => SerializedError[]
-}): TestModule {
-  return {
-    moduleId: props.moduleId,
-    errors: props.errors ?? ((): SerializedError[] => []),
-  } as TestModule
-}
-
-export function testModule(overrides?: {
-  moduleId?: string
-  errors?: () => SerializedError[]
-}): TestModule {
-  return createTestModule({
-    moduleId: overrides?.moduleId ?? DEFAULT_MODULE_ID,
-    errors: overrides?.errors,
-  })
-}
-
-export function createTestCase(overrides?: Partial<TestCase>): TestCase {
-  const defaultModule = createTestModule({ moduleId: DEFAULT_MODULE_ID })
-
-  return {
-    name: DEFAULT_TEST_NAME,
-    fullName: DEFAULT_TEST_FULL_NAME,
-    module: defaultModule,
-    result: () => ({ state: 'passed', errors: [] }) as TestResult,
-    ...overrides,
-  } as TestCase
-}
-
-export function failedTestCase(overrides?: Partial<TestCase>): TestCase {
-  return createTestCase({
-    name: 'should fail',
-    fullName: 'Example Suite > should fail',
-    result: () =>
-      ({
-        state: 'failed',
-        errors: [
-          {
-            message: 'expected 2 to be 3',
-            stack: 'Error: expected 2 to be 3\n    at test.ts:7:19',
-            expected: '3',
-            actual: '2',
-          },
-        ],
-      }) as TestResult,
-    ...overrides,
-  })
-}
-
-export function createUnhandledError(
-  overrides: Partial<SerializedError> = {}
-): SerializedError {
-  return {
-    name: 'Error',
-    message: 'Cannot find module "./helpers"',
-    stack:
-      "Error: Cannot find module './helpers' imported from '/src/example.test.ts'",
-    ...overrides,
-  }
-}

package/project-skills/tdd-guard/reporters/vitest/src/VitestReporter.test.ts

@@ -1,446 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import type { TestModule, TestCase } from 'vitest/node'
-import { VitestReporter } from './VitestReporter'
-import {
-  MemoryStorage,
-  FileStorage,
-  Storage,
-  Config,
-  DEFAULT_DATA_DIR,
-  isFailingTest,
-  isPassingTest,
-  TestResult,
-  Test,
-} from 'tdd-guard'
-import {
-  testModule,
-  failedTestCase,
-  createTestCase,
-  createUnhandledError,
-  createTestResult,
-} from './VitestReporter.test-data'
-import type { FormattedError } from './types'
-import { rmSync, mkdtempSync } from 'node:fs'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-describe('VitestReporter', () => {
-  let sut: Awaited<ReturnType<typeof setupVitestReporter>>
-  const module = testModule()
-  const passedTest = createTestCase()
-  const failedTest = failedTestCase()
-
-  beforeEach(() => {
-    sut = setupVitestReporter()
-  })
-
-  afterEach(() => {
-    sut.cleanup()
-  })
-
-  it('uses FileStorage by default', () => {
-    const reporter = new VitestReporter()
-    expect(reporter['storage']).toBeInstanceOf(FileStorage)
-  })
-
-  it('uses FileStorage when no storage provided', async () => {
-    const localSut = setupVitestReporter({ type: 'file' })
-
-    expect(localSut.reporter['storage']).toBeInstanceOf(FileStorage)
-
-    const result = await localSut.collectAndGetSaved([
-      testModule(),
-      createTestCase(),
-    ])
-
-    expect(result).toBeTruthy()
-    expect(result).toContain('testModules')
-
-    localSut.cleanup()
-  })
-
-  it('accepts Storage instance in constructor', () => {
-    const storage = new MemoryStorage()
-    const reporter = new VitestReporter(storage)
-    expect(reporter['storage']).toBe(storage)
-  })
-
-  it('accepts root path string in constructor', () => {
-    const rootPath = '/some/project/root'
-    const reporter = new VitestReporter(rootPath)
-    expect(reporter['storage']).toBeInstanceOf(FileStorage)
-    // Verify the storage is configured with the correct path
-    const fileStorage = reporter['storage'] as FileStorage
-    const config = fileStorage['config'] as Config
-    const expectedDataDir = join(rootPath, ...DEFAULT_DATA_DIR.split('/'))
-    expect(config.dataDir).toBe(expectedDataDir)
-  })
-
-  describe('when collecting test data', () => {
-    beforeEach(async () => {
-      sut.reporter.onTestModuleCollected(module)
-      sut.reporter.onTestCaseResult(passedTest)
-      sut.reporter.onTestCaseResult(failedTest)
-      await sut.reporter.onTestRunEnd()
-    })
-
-    it('saves output as valid JSON', async () => {
-      const parsed = await sut.getParsedData()
-      expect(parsed).toBeDefined()
-    })
-
-    it('includes test modules', async () => {
-      const parsed = await sut.getParsedData()
-
-      expect(parsed).not.toBeNull()
-      expect(parsed?.testModules).toHaveLength(1)
-      expect(parsed?.testModules[0].moduleId).toBe(module.moduleId)
-    })
-
-    it('includes test cases', async () => {
-      const tests = await sut.getTests()
-      expect(tests).toHaveLength(2)
-    })
-
-    it('captures test states', async () => {
-      const passedTests = await sut.getPassedTests()
-      const failedTests = await sut.getFailedTests()
-
-      expect(passedTests).toHaveLength(1)
-      expect(failedTests).toHaveLength(1)
-    })
-
-    it('includes error information for failed tests', async () => {
-      const failedTests = await sut.getFailedTests()
-      const failedTestData = failedTests[0]
-
-      expect(failedTestData).toBeDefined()
-      expect(failedTestData.state).toBe('failed')
-      expect(failedTestData.errors).toBeDefined()
-      expect(failedTestData.errors?.length).toBeGreaterThan(0)
-    })
-  })
-
-  describe('test state mapping', () => {
-    it.each([
-      ['passed', 'passed'],
-      ['failed', 'failed'],
-      ['skipped', 'skipped'],
-      ['pending', 'skipped'], // pending gets mapped to skipped
-    ] as const)('maps %s to %s', async (vitestState, expected) => {
-      // Given a test with the specified state
-      const testCase = createTestCase({
-        result: () => createTestResult(vitestState),
-      })
-
-      // When we process the test
-      sut.reporter.onTestModuleCollected(module)
-      sut.reporter.onTestCaseResult(testCase)
-      await sut.reporter.onTestRunEnd()
-
-      // Then it should be mapped correctly
-      const tests = await sut.getTests()
-      expect(tests[0]?.state).toBe(expected)
-    })
-  })
-
-  describe('error expected and actual values', () => {
-    let error: FormattedError | undefined
-
-    beforeEach(async () => {
-      // Given a test with an assertion error
-      sut.reporter.onTestModuleCollected(module)
-      sut.reporter.onTestCaseResult(failedTest)
-      await sut.reporter.onTestRunEnd()
-
-      // When we get the failed test errors
-      const failedTests = await sut.getFailedTests()
-      error = failedTests[0]?.errors?.[0]
-    })
-
-    it('includes expected value in error when available', () => {
-      expect(error).toHaveProperty('expected')
-      expect(error?.expected).toBe('3')
-    })
-
-    it('includes actual value in error when available', () => {
-      expect(error).toHaveProperty('actual')
-      expect(error?.actual).toBe('2')
-    })
-  })
-
-  it('handles empty test runs', async () => {
-    // When no tests are collected
-    await sut.reporter.onTestRunEnd()
-
-    // Then output should be valid JSON with empty modules
-    const parsed = await sut.getParsedData()
-
-    expect(parsed).not.toBeNull()
-    expect(parsed).toEqual({ testModules: [], unhandledErrors: [] })
-  })
-
-  describe('storage integration', () => {
-    it('saves test output to storage', async () => {
-      const result = await sut.collectAndGetSaved([
-        testModule(),
-        createTestCase(),
-      ])
-
-      expect(result).toBeTruthy()
-      expect(result).toContain('testModules')
-      expect(result).toContain('passed')
-    })
-
-    it('accumulates multiple test results in storage', async () => {
-      const result = await sut.collectAndGetSaved([
-        module,
-        passedTest,
-        failedTest,
-      ])
-
-      const parsed = JSON.parse(result!)
-      expect(parsed.testModules[0].tests).toHaveLength(2)
-    })
-  })
-
-  describe('stores import errors as unhandled errors', () => {
-    let parsed: TestResult | null
-
-    beforeEach(async () => {
-      // Given a module that was collected but has no tests due to import error
-      const moduleWithImportError = testModule({
-        moduleId: '/src/example.test.ts',
-        errors: () => [createUnhandledError()],
-      })
-
-      // When the test run ends
-      sut.reporter.onTestModuleCollected(moduleWithImportError)
-      await sut.reporter.onTestRunEnd()
-
-      parsed = await sut.getParsedData()
-    })
-
-    it('includes the module in test modules', () => {
-      expect(parsed?.testModules).toHaveLength(1)
-    })
-
-    it('shows module with one synthetic failed test', () => {
-      expect(parsed?.testModules[0].tests).toHaveLength(1)
-      expect(parsed?.testModules[0].tests[0].state).toBe('failed')
-    })
-
-    it('uses module filename as test name', () => {
-      const syntheticTest = parsed?.testModules[0].tests[0]
-      expect(syntheticTest?.name).toBe('example.test.ts')
-      expect(syntheticTest?.fullName).toBe('/src/example.test.ts')
-    })
-
-    it('includes import error details in synthetic test', () => {
-      const syntheticTest = parsed?.testModules[0].tests[0]
-      expect(syntheticTest?.errors).toHaveLength(1)
-      expect(syntheticTest?.errors?.[0].message).toBe(
-        'Cannot find module "./helpers"'
-      )
-    })
-
-    it('includes empty unhandled errors', () => {
-      expect(parsed?.unhandledErrors).toHaveLength(0)
-    })
-
-    it('preserves error message in synthetic test', () => {
-      const error = parsed?.testModules[0].tests[0].errors?.[0]
-      expect(error?.message).toBe('Cannot find module "./helpers"')
-    })
-
-    it('preserves error stack trace in synthetic test', () => {
-      expect(parsed?.testModules[0].tests[0].errors?.[0].stack).toContain(
-        'imported from'
-      )
-    })
-  })
-
-  describe('handles module errors from testModule.errors()', () => {
-    it('creates synthetic test when module has errors', async () => {
-      // Given a module with its own errors (like import errors)
-      const moduleWithErrors = testModule({
-        moduleId: '/src/import-error.test.ts',
-        errors: () => [createUnhandledError()],
-      })
-
-      // When the test run ends
-      sut.reporter.onTestModuleCollected(moduleWithErrors)
-      await sut.reporter.onTestRunEnd([], [], 'failed')
-
-      // Then a synthetic failed test should be created
-      const parsed = await sut.getParsedData()
-      expect(parsed?.testModules[0].tests).toHaveLength(1)
-      expect(parsed?.testModules[0].tests[0].state).toBe('failed')
-    })
-  })
-
-  describe('handles testModules parameter', () => {
-    it('receives test modules in onTestRunEnd', async () => {
-      const module1 = testModule({ moduleId: '/test1.ts' })
-      const module2 = testModule({ moduleId: '/test2.ts' })
-
-      await sut.reporter.onTestRunEnd([module1, module2])
-
-      const parsed = await sut.getParsedData()
-      expect(parsed?.testModules).toEqual([]) // Empty because we didn't collect them
-    })
-  })
-
-  describe('handles unhandled errors', () => {
-    it('includes unhandled errors in output when provided', async () => {
-      const unhandledError = createUnhandledError({
-        message: 'Connection failed',
-        name: 'NetworkError',
-      })
-
-      await sut.reporter.onTestRunEnd([], [unhandledError])
-
-      const parsed = await sut.getParsedData()
-      expect(parsed?.unhandledErrors).toEqual([
-        expect.objectContaining({
-          message: 'Connection failed',
-          name: 'NetworkError',
-        }),
-      ])
-    })
-
-    it('returns empty array when no errors provided', async () => {
-      await sut.reporter.onTestRunEnd()
-
-      const parsed = await sut.getParsedData()
-      expect(parsed?.unhandledErrors).toEqual([])
-    })
-  })
-
-  describe('when test run ends with reason', () => {
-    it('captures "failed" reason in output', async () => {
-      const moduleWithImportError = testModule({
-        moduleId: '/src/linters/eslint/helpers.test.ts',
-      })
-
-      sut.reporter.onTestModuleCollected(moduleWithImportError)
-      await sut.reporter.onTestRunEnd([], [], 'failed')
-
-      const parsed = await sut.getParsedData()
-
-      expect(parsed?.reason).toBe('failed')
-      // When no errors are provided, module should have no tests
-      expect(parsed?.testModules[0].tests).toHaveLength(0)
-    })
-
-    it('creates synthetic test when module fails with errors', async () => {
-      const moduleWithImportError = testModule({
-        moduleId: '/src/failing.test.ts',
-        errors: () => [createUnhandledError()],
-      })
-
-      sut.reporter.onTestModuleCollected(moduleWithImportError)
-      await sut.reporter.onTestRunEnd([], [], 'failed')
-
-      const parsed = await sut.getParsedData()
-
-      expect(parsed?.reason).toBe('failed')
-      expect(parsed?.testModules[0].tests).toHaveLength(1)
-      expect(parsed?.testModules[0].tests[0].state).toBe('failed')
-    })
-
-    it('captures "interrupted" reason in output', async () => {
-      await sut.reporter.onTestRunEnd([], [], 'interrupted')
-
-      const parsed = await sut.getParsedData()
-      expect(parsed?.reason).toBe('interrupted')
-    })
-
-    it('captures "passed" reason in output', async () => {
-      sut.reporter.onTestModuleCollected(module)
-      sut.reporter.onTestCaseResult(passedTest)
-      await sut.reporter.onTestRunEnd([], [], 'passed')
-
-      const parsed = await sut.getParsedData()
-      expect(parsed?.reason).toBe('passed')
-    })
-  })
-})
-
-function setupVitestReporter(options?: { type: 'file' | 'memory' }) {
-  const { storage, cleanup } = createTestStorage(options?.type)
-  const reporter = new VitestReporter(storage)
-
-  const collectAndGetSaved = async (
-    items: Array<TestModule | TestCase>
-  ): Promise<string | null> => {
-    collectTestData(reporter, items)
-    await reporter.onTestRunEnd()
-    return storage.getTest()
-  }
-
-  const getParsedData = async (): Promise<TestResult | null> => {
-    const content = await storage.getTest()
-    return content ? JSON.parse(content) : null
-  }
-
-  const getTests = async (): Promise<Test[]> => {
-    return getTestsFromStorage(storage)
-  }
-
-  const getPassedTests = async (): Promise<(Test & { state: 'passed' })[]> => {
-    const tests = await getTests()
-    return tests.filter(isPassingTest)
-  }
-
-  const getFailedTests = async (): Promise<(Test & { state: 'failed' })[]> => {
-    const tests = await getTests()
-    return tests.filter(isFailingTest)
-  }
-
-  return {
-    reporter,
-    storage,
-    collectAndGetSaved,
-    getParsedData,
-    getTests,
-    getPassedTests,
-    getFailedTests,
-    cleanup,
-  }
-}
-
-function createTestStorage(type: 'file' | 'memory' = 'memory'): {
-  storage: Storage
-  cleanup: () => void
-} {
-  if (type === 'file') {
-    const projectRoot = mkdtempSync(join(tmpdir(), 'vitest-reporter-test-'))
-    const config = new Config({ projectRoot })
-    const storage = new FileStorage(config)
-    const cleanup = () => rmSync(projectRoot, { recursive: true, force: true })
-    return { storage, cleanup }
-  }
-
-  return { storage: new MemoryStorage(), cleanup: () => {} }
-}
-
-function collectTestData(
-  reporter: VitestReporter,
-  items: Array<TestModule | TestCase>
-): void {
-  for (const item of items) {
-    if ('moduleId' in item && !('module' in item)) {
-      reporter.onTestModuleCollected(item as TestModule)
-    } else {
-      reporter.onTestCaseResult(item as TestCase)
-    }
-  }
-}
-
-async function getTestsFromStorage(storage: Storage): Promise<Test[]> {
-  const content = await storage.getTest()
-  if (!content) return []
-  const parsed: TestResult = JSON.parse(content)
-  return parsed.testModules[0]?.tests ?? []
-}