xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,110 +0,0 @@
-import { Reporter, TestModule, TestCase, TestRunEndReason } from 'vitest/node'
-import type { SerializedError } from '@vitest/utils'
-import { Storage, FileStorage, Config } from 'tdd-guard'
-import { basename } from 'node:path'
-import type {
-  CollectedModuleData,
-  FormattedError,
-  FormattedTest,
-  ModuleDataMap,
-  ModuleResult,
-  TestRunOutput,
-} from './types'
-
-export class VitestReporter implements Reporter {
-  private readonly storage: Storage
-  private readonly collectedData: ModuleDataMap = new Map()
-
-  constructor(storageOrRoot?: Storage | string) {
-    this.storage =
-      typeof storageOrRoot === 'string'
-        ? new FileStorage(new Config({ projectRoot: storageOrRoot }))
-        : (storageOrRoot ?? new FileStorage())
-  }
-
-  onTestModuleCollected(testModule: TestModule): void {
-    this.collectedData.set(testModule.moduleId, {
-      module: testModule,
-      tests: [],
-    })
-  }
-
-  onTestCaseResult(testCase: TestCase): void {
-    const moduleId = testCase.module.moduleId
-    if (!moduleId) return
-
-    this.collectedData.get(moduleId)?.tests.push(testCase)
-  }
-
-  async onTestRunEnd(
-    _testModules?: ReadonlyArray<TestModule>,
-    unhandledErrors?: ReadonlyArray<SerializedError>,
-    reason?: TestRunEndReason
-  ): Promise<void> {
-    // _testModules contains only module metadata, we use collected data from callbacks
-    const formattedModules = formatAllModuleResults(this.collectedData)
-    const output = createTestRunOutput(
-      formattedModules,
-      unhandledErrors,
-      reason
-    )
-    await this.storage.saveTest(JSON.stringify(output, null, 2))
-  }
-}
-
-function createTestRunOutput(
-  testModules: ModuleResult[],
-  unhandledErrors?: ReadonlyArray<SerializedError>,
-  reason?: TestRunEndReason
-): TestRunOutput {
-  return {
-    testModules,
-    unhandledErrors: unhandledErrors ?? [],
-    ...(reason && { reason }),
-  }
-}
-
-function formatAllModuleResults(collectedData: ModuleDataMap): ModuleResult[] {
-  return Array.from(collectedData.values()).map((data) => ({
-    moduleId: data.module.moduleId,
-    tests: moduleFailedToLoad(data)
-      ? createTestForFailedModule(data)
-      : formatNormalTests(data),
-  }))
-}
-
-function moduleFailedToLoad(data: CollectedModuleData): boolean {
-  return data.module.errors().length > 0 && data.tests.length === 0
-}
-
-function createTestForFailedModule(data: CollectedModuleData): FormattedTest[] {
-  return [
-    {
-      name: basename(data.module.moduleId),
-      fullName: data.module.moduleId,
-      state: 'failed',
-      errors: data.module.errors().map(formatError),
-    },
-  ]
-}
-
-function formatNormalTests(data: CollectedModuleData): FormattedTest[] {
-  return data.tests.map((test) => {
-    const result = test.result()
-    return {
-      name: test.name,
-      fullName: test.fullName,
-      state: result.state === 'pending' ? 'skipped' : result.state,
-      errors: result.errors?.map(formatError),
-    }
-  })
-}
-
-function formatError(error: SerializedError): FormattedError {
-  return {
-    message: error.message,
-    stack: error.stack,
-    expected: error.expected,
-    actual: error.actual,
-  }
-}

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

@@ -1,4 +0,0 @@
-import { VitestReporter } from './VitestReporter'
-
-export { VitestReporter }
-export default VitestReporter

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

@@ -1,39 +0,0 @@
-import type {
-  TestState,
-  TestRunEndReason,
-  TestModule,
-  TestCase,
-} from 'vitest/node'
-import type { SerializedError } from '@vitest/utils'
-
-export type ModuleDataMap = Map<string, CollectedModuleData>
-
-export type CollectedModuleData = {
-  module: TestModule
-  tests: TestCase[]
-}
-
-export type FormattedError = {
-  message: string
-  stack?: string
-  expected?: unknown
-  actual?: unknown
-}
-
-export type FormattedTest = {
-  name: string
-  fullName: string
-  state: TestState
-  errors?: FormattedError[]
-}
-
-export type ModuleResult = {
-  moduleId: string
-  tests: FormattedTest[]
-}
-
-export type TestRunOutput = {
-  testModules: ModuleResult[]
-  unhandledErrors: readonly SerializedError[]
-  reason?: TestRunEndReason
-}

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

@@ -1,11 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "composite": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "tsBuildInfoFile": "./dist/tsconfig.tsbuildinfo"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["**/*.test.ts", "**/*.spec.ts"]
-}

package/project-skills/tdd-guard/src/cli/buildContext.test.ts

@@ -1,200 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { buildContext } from './buildContext'
-import { MemoryStorage } from '../storage/MemoryStorage'
-
-describe('buildContext', () => {
-  let storage: MemoryStorage
-
-  beforeEach(() => {
-    storage = new MemoryStorage()
-  })
-
-  it('should return a context with default values when storage is empty', async () => {
-    const context = await buildContext(storage)
-
-    expect(context).toEqual({
-      modifications: '',
-      test: '',
-      todo: '',
-      lint: {
-        hasIssues: false,
-        summary: 'No lint data available',
-        issuesByFile: new Map(),
-        totalIssues: 0,
-        errorCount: 0,
-        warningCount: 0,
-      },
-      instructions: undefined,
-    })
-  })
-
-  it('should return context with values from storage', async () => {
-    await storage.saveModifications('some modifications content')
-    await storage.saveTest('test code')
-    await storage.saveTodo('pending: implement feature')
-
-    const context = await buildContext(storage)
-
-    expect(context).toEqual({
-      modifications: 'some modifications content',
-      test: 'test code',
-      todo: 'pending: implement feature',
-      lint: {
-        hasIssues: false,
-        summary: 'No lint data available',
-        issuesByFile: new Map(),
-        totalIssues: 0,
-        errorCount: 0,
-        warningCount: 0,
-      },
-    })
-  })
-
-  it('should parse modifications JSON data when valid JSON is stored', async () => {
-    const modificationsData = {
-      file_path: '/src/example.ts',
-      content: 'new file content',
-    }
-    const modificationsJson = JSON.stringify(modificationsData)
-    await storage.saveModifications(modificationsJson)
-    await storage.saveTest('test code')
-    await storage.saveTodo('pending: implement feature')
-
-    const context = await buildContext(storage)
-
-    expect(context).toEqual({
-      modifications: JSON.stringify(modificationsData, null, 2),
-      test: 'test code',
-      todo: 'pending: implement feature',
-      lint: {
-        hasIssues: false,
-        summary: 'No lint data available',
-        issuesByFile: new Map(),
-        totalIssues: 0,
-        errorCount: 0,
-        warningCount: 0,
-      },
-    })
-  })
-
-  it('should pretty-print modifications JSON for better readability', async () => {
-    const modificationsData = {
-      file_path: '/src/Calculator.test.ts',
-      old_string:
-        "describe('Calculator', () => {\n  test('should add two numbers correctly', () => {\n    const result = calculator.add(2, 3)\n    expect(result).toBe(5)\n  })\n})",
-      new_string:
-        "describe('Calculator', () => {\n  test('should add two numbers correctly', () => {\n    const result = calculator.add(2, 3)\n    expect(result).toBe(5)\n  })\n  \n  test('should divide two numbers correctly', () => {\n    const result = calculator.divide(4, 2)\n    expect(result).toBe(2)\n  })\n})",
-    }
-    await storage.saveModifications(JSON.stringify(modificationsData))
-
-    const context = await buildContext(storage)
-
-    // Should be pretty-printed, not a compact JSON string
-    expect(context.modifications).toBe(
-      JSON.stringify(modificationsData, null, 2)
-    )
-  })
-
-  it('should process valid lint data when stored', async () => {
-    const lintData = {
-      timestamp: '2024-01-01T00:00:00Z',
-      files: ['/src/example.ts'],
-      issues: [
-        {
-          file: '/src/example.ts',
-          line: 10,
-          column: 5,
-          severity: 'error',
-          message: 'Missing semicolon',
-          rule: 'semi',
-        },
-      ],
-      errorCount: 1,
-      warningCount: 0,
-      hasNotifiedAboutLintIssues: false,
-    }
-    await storage.saveLint(JSON.stringify(lintData))
-
-    const context = await buildContext(storage)
-
-    expect(context.lint).toEqual({
-      hasIssues: true,
-      summary: '1 lint issue found (1 error, 0 warnings)',
-      issuesByFile: new Map([
-        ['/src/example.ts', ['  Line 10:5 - error: Missing semicolon (semi)']],
-      ]),
-      totalIssues: 1,
-      errorCount: 1,
-      warningCount: 0,
-    })
-  })
-
-  it('should handle invalid lint JSON gracefully', async () => {
-    await storage.saveLint('invalid json')
-
-    const context = await buildContext(storage)
-
-    // Should fall back to default lint data
-    expect(context.lint).toEqual({
-      hasIssues: false,
-      summary: 'No lint data available',
-      issuesByFile: new Map(),
-      totalIssues: 0,
-      errorCount: 0,
-      warningCount: 0,
-    })
-  })
-
-  it('should handle lint data that fails schema validation', async () => {
-    // Missing required fields
-    const invalidLintData = {
-      timestamp: '2024-01-01T00:00:00Z',
-      // Missing: files, issues, errorCount, warningCount, hasNotifiedAboutLintIssues
-    }
-    await storage.saveLint(JSON.stringify(invalidLintData))
-
-    const context = await buildContext(storage)
-
-    // Should fall back to default lint data
-    expect(context.lint).toEqual({
-      hasIssues: false,
-      summary: 'No lint data available',
-      issuesByFile: new Map(),
-      totalIssues: 0,
-      errorCount: 0,
-      warningCount: 0,
-    })
-  })
-
-  it('should handle lint data with no issues', async () => {
-    const lintData = {
-      timestamp: '2024-01-01T00:00:00Z',
-      files: ['/src/example.ts'],
-      issues: [],
-      errorCount: 0,
-      warningCount: 0,
-      hasNotifiedAboutLintIssues: false,
-    }
-    await storage.saveLint(JSON.stringify(lintData))
-
-    const context = await buildContext(storage)
-
-    expect(context.lint).toEqual({
-      hasIssues: false,
-      summary: 'No lint issues found',
-      issuesByFile: new Map(),
-      totalIssues: 0,
-      errorCount: 0,
-      warningCount: 0,
-    })
-  })
-
-  it('should include instructions when available in storage', async () => {
-    const customInstructions = '## Custom TDD Rules\n1. Write tests first'
-    await storage.saveInstructions(customInstructions)
-
-    const context = await buildContext(storage)
-
-    expect(context.instructions).toBe(customInstructions)
-  })
-})

package/project-skills/tdd-guard/src/cli/buildContext.ts

@@ -1,48 +0,0 @@
-import { Storage } from '../storage/Storage'
-import { LintDataSchema } from '../contracts/schemas/lintSchemas'
-import { Context } from '../contracts/types/Context'
-import { processLintData } from '../processors/lintProcessor'
-
-export async function buildContext(storage: Storage): Promise<Context> {
-  const [modifications, rawTest, todo, lint, instructions] = await Promise.all([
-    storage.getModifications(),
-    storage.getTest(),
-    storage.getTodo(),
-    storage.getLint(),
-    storage.getInstructions(),
-  ])
-
-  let processedLintData
-  try {
-    if (lint) {
-      const rawLintData = LintDataSchema.parse(JSON.parse(lint))
-      processedLintData = processLintData(rawLintData)
-    } else {
-      processedLintData = processLintData()
-    }
-  } catch {
-    processedLintData = processLintData()
-  }
-
-  return {
-    modifications: formatModifications(modifications ?? ''),
-    test: rawTest ?? '',
-    todo: todo ?? '',
-    lint: processedLintData,
-    instructions: instructions ?? undefined,
-  }
-}
-
-function formatModifications(modifications: string): string {
-  if (!modifications) {
-    return ''
-  }
-
-  try {
-    const parsed = JSON.parse(modifications)
-    return JSON.stringify(parsed, null, 2)
-  } catch {
-    // If it's not valid JSON, leave it as is
-    return modifications
-  }
-}

package/project-skills/tdd-guard/src/cli/tdd-guard.test.ts

@@ -1,159 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'vitest'
-import { spawn } from 'child_process'
-import path from 'path'
-import fs from 'fs/promises'
-import os from 'os'
-import { FileStorage } from '../storage/FileStorage'
-import { Config } from '../config/Config'
-import { ModelClientProvider } from '../providers/ModelClientProvider'
-import { run } from './tdd-guard'
-import { testData } from '@testUtils'
-
-describe('tdd-guard CLI', () => {
-  const cliPath = path.join(__dirname, 'tdd-guard.ts')
-
-  describe('CLI Behavior', () => {
-    test('has shebang for direct execution', async () => {
-      const content = await fs.readFile(cliPath, 'utf-8')
-      const firstLine = content.split('\n')[0].trim()
-
-      expect(firstLine).toBe('#!/usr/bin/env node')
-    })
-
-    test('exits with status 0 on invalid JSON', async () => {
-      const invalidJson = '{ invalid json'
-
-      const { exitCode } = await runCli(invalidJson)
-
-      expect(exitCode).toBe(0)
-    })
-
-    test('logs error to stderr on invalid JSON', async () => {
-      const invalidJson = '{ invalid json'
-
-      const { stderr } = await runCli(invalidJson)
-
-      expect(stderr).toContain('Failed to parse hook data')
-    })
-  })
-
-  describe('Data Persistence', () => {
-    let projectRoot: string
-    let storage: FileStorage
-    let testConfig: Config
-    let modelProvider: ModelClientProvider
-    const originalEnv = process.env
-
-    beforeEach(async () => {
-      process.env = { ...originalEnv }
-      projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'tdd-guard-test-'))
-      testConfig = new Config({ projectRoot })
-      storage = new FileStorage(testConfig)
-      modelProvider = testData.modelClientProvider()
-    })
-
-    afterEach(async () => {
-      process.env = originalEnv
-      await fs.rm(projectRoot, { recursive: true, force: true })
-    })
-
-    test('uses projectRoot from Config', async () => {
-      const hookData = testData.editOperation()
-      await run(JSON.stringify(hookData), testConfig, storage, modelProvider)
-
-      expect(await pathExists(testConfig.dataDir)).toBe(true)
-    })
-
-    test('saves Edit data', async () => {
-      const hookData = testData.editOperation()
-
-      await run(JSON.stringify(hookData), testConfig, storage, modelProvider)
-
-      const savedModifications = await storage.getModifications()
-      expect(JSON.parse(savedModifications!)).toStrictEqual(hookData)
-    })
-
-    test('saves Write data', async () => {
-      const hookData = testData.writeOperation()
-
-      await run(JSON.stringify(hookData), testConfig, storage, modelProvider)
-
-      const savedModifications = await storage.getModifications()
-      expect(JSON.parse(savedModifications!)).toStrictEqual(hookData)
-    })
-
-    test('saves TodoWrite data', async () => {
-      const hookData = testData.todoWriteOperation()
-
-      await run(JSON.stringify(hookData), testConfig, storage, modelProvider)
-
-      const savedTodos = await storage.getTodo()
-      expect(JSON.parse(savedTodos!)).toStrictEqual(hookData)
-    })
-
-    test('saves MultiEdit data', async () => {
-      const hookData = testData.multiEditOperation()
-
-      await run(JSON.stringify(hookData), testConfig, storage, modelProvider)
-
-      const savedModifications = await storage.getModifications()
-      expect(JSON.parse(savedModifications!)).toStrictEqual(hookData)
-    })
-
-    test('uses provided ModelClientProvider', async () => {
-      await storage.saveConfig(JSON.stringify({ guardEnabled: true }))
-
-      const hookData = testData.editOperation()
-
-      const result = await run(
-        JSON.stringify(hookData),
-        testConfig,
-        storage,
-        modelProvider
-      )
-
-      // The mock provider always returns undefined decision
-      expect(result.decision).toBe(undefined)
-      expect(result.reason).toContain('Using mock model client')
-    })
-  })
-})
-
-// Helper to check if file/directory exists
-async function pathExists(filePath: string): Promise<boolean> {
-  return fs
-    .access(filePath)
-    .then(() => true)
-    .catch(() => false)
-}
-
-// Helper function for CLI subprocess tests
-async function runCli(
-  input: string
-): Promise<{ exitCode: number; stderr: string; stdout: string }> {
-  const cliPath = path.join(__dirname, 'tdd-guard.ts')
-
-  return new Promise((resolve) => {
-    const npxPath = process.platform === 'win32' ? 'npx.cmd' : 'npx'
-    const proc = spawn(npxPath, ['tsx', cliPath], {
-      env: { ...process.env },
-      shell: process.platform === 'win32',
-    })
-
-    let stderr = ''
-    let stdout = ''
-    proc.stderr.on('data', (data) => {
-      stderr += data.toString()
-    })
-    proc.stdout.on('data', (data) => {
-      stdout += data.toString()
-    })
-
-    proc.stdin.write(input)
-    proc.stdin.end()
-
-    proc.on('close', (code) => {
-      resolve({ exitCode: code ?? 1, stderr, stdout })
-    })
-  })
-}

package/project-skills/tdd-guard/src/cli/tdd-guard.ts

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-import 'dotenv/config'
-import { processHookData } from '../hooks/processHookData'
-import { Storage } from '../storage/Storage'
-import { FileStorage } from '../storage/FileStorage'
-import { validator } from '../validation/validator'
-import { Config } from '../config/Config'
-import { ModelClientProvider } from '../providers/ModelClientProvider'
-import { ValidationResult } from '../contracts/types/ValidationResult'
-
-export async function run(
-  input: string,
-  config?: Config,
-  storage?: Storage,
-  provider?: ModelClientProvider
-): Promise<ValidationResult> {
-  const appConfig = config ?? new Config()
-  const actualStorage = storage ?? new FileStorage(appConfig)
-  const modelProvider = provider ?? new ModelClientProvider()
-  const modelClient = modelProvider.getModelClient(appConfig)
-
-  return processHookData(input, {
-    storage: actualStorage,
-    validator: (context) => validator(context, modelClient),
-  })
-}
-
-// Only run if this is the main module
-if (require.main === module) {
-  let inputData = ''
-  process.stdin.setEncoding('utf8')
-
-  process.stdin.on('data', (chunk) => {
-    inputData += chunk
-  })
-
-  process.stdin.on('end', async () => {
-    try {
-      const result = await run(inputData)
-      console.log(JSON.stringify(result))
-    } catch (error) {
-      console.error('Failed to parse hook data:', error)
-    } finally {
-      process.exit(0)
-    }
-  })
-}