xtrm-tools 2.0.0

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

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

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

@@ -0,0 +1,35 @@
+{
+  "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/src/cli/buildContext.test.ts

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

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

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

@@ -0,0 +1,48 @@
+#!/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)
+    }
+  })
+}