xtrm-tools 2.0.0

package/project-skills/tdd-guard/src/processors/testResults/TestResultsProcessor.ts

@@ -0,0 +1,255 @@
+import {
+  TestResultSchema as VitestTestResultSchema,
+  TestResult,
+  isFailingTest,
+  isPassingTest,
+} from '../../contracts/schemas/reporterSchemas'
+import { PytestResultSchema } from '../../contracts/schemas/pytestSchemas'
+
+export class TestResultsProcessor {
+  process(jsonData: string, framework: 'vitest' | 'pytest' = 'vitest'): string {
+    const parseResult = this.parseAndValidate(jsonData, framework)
+    if (!parseResult.success) {
+      return parseResult.error
+    }
+
+    const data = parseResult.data
+    if (data.testModules.length === 0) {
+      return 'No test results found.'
+    }
+
+    const counts = this.countTestsAndModules(data)
+    const reasonOutput = this.formatReason(data)
+    const moduleOutput = this.formatModules(data)
+    const errorOutput = this.formatUnhandledErrors(data)
+    const summaryOutput = this.formatSummary(counts)
+
+    return `${reasonOutput}${moduleOutput}${errorOutput}\n${summaryOutput}`
+  }
+
+  private countTestsAndModules(data: TestResult): {
+    failedCount: number
+    passedCount: number
+    failedModuleCount: number
+    passedModuleCount: number
+  } {
+    let failedCount = 0
+    let passedCount = 0
+    let failedModuleCount = 0
+    let passedModuleCount = 0
+
+    for (const module of data.testModules) {
+      const moduleCounts = this.countModuleTests(module.tests)
+
+      failedCount += moduleCounts.failed
+      passedCount += moduleCounts.passed
+
+      if (moduleCounts.failed > 0) {
+        failedModuleCount++
+      } else if (module.tests.length === 0 && data.reason === 'failed') {
+        // Module with no tests in a failed test run should be counted as failed
+        failedModuleCount++
+      } else {
+        passedModuleCount++
+      }
+    }
+
+    return { failedCount, passedCount, failedModuleCount, passedModuleCount }
+  }
+
+  private countModuleTests(tests: TestResult['testModules'][0]['tests']): {
+    failed: number
+    passed: number
+  } {
+    let failed = 0
+    let passed = 0
+
+    for (const test of tests) {
+      if (isFailingTest(test)) {
+        failed++
+      } else if (isPassingTest(test)) {
+        passed++
+      }
+    }
+
+    return { failed, passed }
+  }
+
+  private formatModules(data: TestResult): string {
+    let output = ''
+
+    for (const module of data.testModules) {
+      const testCount = module.tests.length
+      const failedTests = module.tests.filter(isFailingTest)
+
+      if (failedTests.length === 0) {
+        // Check if this module should be marked as failed due to test run reason
+        if (testCount === 0 && data.reason === 'failed') {
+          output += ` ❯ ${module.moduleId} (${testCount} tests | 0 failed) 0ms\n`
+        } else {
+          output += ` ✓ ${module.moduleId} (${testCount} tests) 0ms\n`
+        }
+      } else {
+        output += ` ❯ ${module.moduleId} (${testCount} tests | ${failedTests.length} failed) 0ms\n`
+        output += this.formatFailingModuleTests(module.tests)
+      }
+    }
+
+    return output
+  }
+
+  private formatFailingModuleTests(
+    tests: TestResult['testModules'][0]['tests']
+  ): string {
+    let output = ''
+
+    for (const test of tests) {
+      output += this.formatSingleTest(test)
+    }
+
+    return output
+  }
+
+  private formatSingleTest(
+    test: TestResult['testModules'][0]['tests'][0]
+  ): string {
+    if (isPassingTest(test)) {
+      return `   ✓ ${test.fullName} 0ms\n`
+    }
+
+    if (isFailingTest(test)) {
+      return this.formatFailingTest(test)
+    }
+
+    return ''
+  }
+
+  private formatFailingTest(
+    test: TestResult['testModules'][0]['tests'][0]
+  ): string {
+    let output = `   × ${test.fullName} 0ms\n`
+
+    if (test.errors && test.errors.length > 0) {
+      for (const error of test.errors) {
+        output += `     → ${error.message}\n`
+      }
+    }
+
+    return output
+  }
+
+  private formatReason(data: TestResult): string {
+    if (!data.reason) {
+      return ''
+    }
+
+    if (data.reason === 'failed') {
+      const hasEmptyModules = data.testModules.some(
+        (module) => module.tests.length === 0
+      )
+      if (hasEmptyModules) {
+        return 'Test run failed - This is likely when an imported module can not be found and as such no tests were collected, resulting in inaccurate test run results.\n\n'
+      }
+    }
+
+    return ''
+  }
+
+  private formatUnhandledErrors(data: TestResult): string {
+    if (!data.unhandledErrors || data.unhandledErrors.length === 0) {
+      return ''
+    }
+
+    let output = '\nUnhandled Errors:\n'
+    for (const error of data.unhandledErrors) {
+      if (error.name) {
+        output += ` × ${error.name}: ${error.message}\n`
+      } else {
+        output += ` × ${error.message || error.toString()}\n`
+      }
+
+      if (error.stack) {
+        output += `   Stack:\n`
+        const stackLines = error.stack.split('\n')
+        for (const line of stackLines) {
+          if (line.trim()) {
+            output += `     ${line}\n`
+          }
+        }
+      }
+    }
+    return output
+  }
+
+  private formatSummary(counts: {
+    failedCount: number
+    passedCount: number
+    failedModuleCount: number
+    passedModuleCount: number
+  }): string {
+    const { failedCount, passedCount, failedModuleCount, passedModuleCount } =
+      counts
+    let output = ''
+
+    if (failedCount > 0 || failedModuleCount > 0) {
+      if (passedCount > 0) {
+        output += ` Test Files  ${failedModuleCount} failed | ${passedModuleCount} passed (${failedModuleCount + passedModuleCount})\n`
+        output += `      Tests  ${failedCount} failed | ${passedCount} passed (${failedCount + passedCount})\n`
+      } else {
+        output += ` Test Files  ${failedModuleCount} failed (${failedModuleCount})\n`
+        output += `      Tests  ${failedCount} failed (${failedCount})\n`
+      }
+    } else {
+      output += ` Test Files  ${passedModuleCount} passed (${passedModuleCount})\n`
+      output += `      Tests  ${passedCount} passed (${passedCount})\n`
+    }
+
+    return output
+  }
+
+  private parseAndValidate(
+    jsonData: string,
+    framework: 'vitest' | 'pytest'
+  ): { success: true; data: TestResult } | { success: false; error: string } {
+    const parsed = this.parseJson(jsonData)
+    if (!parsed.success) {
+      return parsed
+    }
+
+    const schema =
+      framework === 'pytest' ? PytestResultSchema : VitestTestResultSchema
+    const result = schema.safeParse(parsed.data)
+    if (!result.success) {
+      return { success: false, error: this.getValidationError(parsed.data) }
+    }
+
+    return { success: true, data: result.data }
+  }
+
+  private parseJson(
+    jsonData: string
+  ): { success: true; data: unknown } | { success: false; error: string } {
+    try {
+      const firstParse = JSON.parse(jsonData)
+      // Handle double-encoded JSON (common in both Vitest and pytest reporters)
+      if (typeof firstParse === 'string') {
+        const data = JSON.parse(firstParse)
+        return { success: true, data }
+      }
+      return { success: true, data: firstParse }
+    } catch {
+      return { success: false, error: 'Invalid JSON format.' }
+    }
+  }
+
+  private getValidationError(parsed: unknown): string {
+    if (
+      typeof parsed === 'object' &&
+      parsed !== null &&
+      !('testModules' in parsed)
+    ) {
+      return 'No test results found.'
+    }
+    return 'Invalid test result format.'
+  }
+}

package/project-skills/tdd-guard/src/providers/LinterProvider.test.ts

@@ -0,0 +1,43 @@
+import { describe, test, expect } from 'vitest'
+import { LinterProvider } from './LinterProvider'
+import { Config } from '../config/Config'
+import { ESLint } from '../linters/eslint/ESLint'
+import { GolangciLint } from '../linters/golangci/GolangciLint'
+
+describe('LinterProvider', () => {
+  test('returns ESLint when config linterType is eslint', () => {
+    const config = new Config({ linterType: 'eslint' })
+
+    const provider = new LinterProvider()
+    const linter = provider.getLinter(config)
+
+    expect(linter).toBeInstanceOf(ESLint)
+  })
+
+  test('returns GolangciLint when config linterType is golangci-lint', () => {
+    const config = new Config({ linterType: 'golangci-lint' })
+
+    const provider = new LinterProvider()
+    const linter = provider.getLinter(config)
+
+    expect(linter).toBeInstanceOf(GolangciLint)
+  })
+
+  test('returns null when config linterType is explicitly undefined', () => {
+    const config = new Config({ linterType: undefined })
+
+    const provider = new LinterProvider()
+    const linter = provider.getLinter(config)
+
+    expect(linter).toBeNull()
+  })
+
+  test('returns null when config linterType is unknown value', () => {
+    const config = new Config({ linterType: 'unknown-linter' })
+
+    const provider = new LinterProvider()
+    const linter = provider.getLinter(config)
+
+    expect(linter).toBeNull()
+  })
+})

package/project-skills/tdd-guard/src/providers/LinterProvider.ts

@@ -0,0 +1,20 @@
+import { Linter } from '../linters/Linter'
+import { Config } from '../config/Config'
+import { ESLint } from '../linters/eslint/ESLint'
+import { GolangciLint } from '../linters/golangci/GolangciLint'
+
+export class LinterProvider {
+  getLinter(config?: Config): Linter | null {
+    const actualConfig = config ?? new Config()
+
+    switch (actualConfig.linterType) {
+      case 'eslint':
+        return new ESLint()
+      case 'golangci-lint':
+        return new GolangciLint()
+      case undefined:
+      default:
+        return null
+    }
+  }
+}

package/project-skills/tdd-guard/src/providers/ModelClientProvider.test.ts

@@ -0,0 +1,68 @@
+import { describe, test, expect } from 'vitest'
+import { ModelClientProvider } from './ModelClientProvider'
+import { Config } from '../config/Config'
+import { ClaudeCli } from '../validation/models/ClaudeCli'
+import { AnthropicApi } from '../validation/models/AnthropicApi'
+import { ClaudeAgentSdk } from '../validation/models/ClaudeAgentSdk'
+
+describe('ModelClientProvider', () => {
+  test('uses default config when no config is provided', () => {
+    const provider = new ModelClientProvider()
+    const client = provider.getModelClient()
+
+    expect(client['config']).toBeDefined()
+  })
+
+  test('returns ClaudeCli when config validationClient is cli', () => {
+    const config = new Config({ validationClient: 'cli' })
+
+    const provider = new ModelClientProvider()
+    const client = provider.getModelClient(config)
+
+    expect(client).toBeInstanceOf(ClaudeCli)
+  })
+
+  test('returns AnthropicApi when config validationClient is api', () => {
+    const config = new Config({ validationClient: 'api' })
+
+    const provider = new ModelClientProvider()
+    const client = provider.getModelClient(config)
+
+    expect(client).toBeInstanceOf(AnthropicApi)
+  })
+
+  test('returns ClaudeAgentSdk when config validationClient is sdk', () => {
+    const config = new Config({ validationClient: 'sdk' })
+
+    const provider = new ModelClientProvider()
+    const client = provider.getModelClient(config)
+
+    expect(client).toBeInstanceOf(ClaudeAgentSdk)
+  })
+
+  test('passes config with API key to AnthropicApi client', () => {
+    const config = new Config({
+      validationClient: 'api',
+      anthropicApiKey: 'test-api-key-123',
+    })
+
+    const provider = new ModelClientProvider()
+    const client = provider.getModelClient(config)
+
+    expect(client).toBeInstanceOf(AnthropicApi)
+    expect(client['config'].anthropicApiKey).toBe('test-api-key-123')
+  })
+
+  test('passes config with useSystemClaude to ClaudeCli client', () => {
+    const config = new Config({
+      validationClient: 'cli',
+      useSystemClaude: true,
+    })
+
+    const provider = new ModelClientProvider()
+    const client = provider.getModelClient(config)
+
+    expect(client).toBeInstanceOf(ClaudeCli)
+    expect(client['config'].useSystemClaude).toBe(true)
+  })
+})

package/project-skills/tdd-guard/src/providers/ModelClientProvider.ts

@@ -0,0 +1,22 @@
+import { IModelClient } from '../contracts/types/ModelClient'
+import { Config } from '../config/Config'
+import { ClaudeCli } from '../validation/models/ClaudeCli'
+import { AnthropicApi } from '../validation/models/AnthropicApi'
+import { ClaudeAgentSdk } from '../validation/models/ClaudeAgentSdk'
+
+export class ModelClientProvider {
+  getModelClient(config?: Config): IModelClient {
+    const actualConfig = config ?? new Config()
+
+    switch (actualConfig.validationClient) {
+      case 'sdk':
+        return new ClaudeAgentSdk(actualConfig)
+      case 'api':
+        return new AnthropicApi(actualConfig)
+      case 'cli':
+        return new ClaudeCli(actualConfig)
+      default:
+        return new ClaudeCli(actualConfig)
+    }
+  }
+}

package/project-skills/tdd-guard/src/storage/FileStorage.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { FileStorage } from './FileStorage'
+import { Config, DEFAULT_DATA_DIR } from '../config/Config'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+
+describe('FileStorage', () => {
+  let projectRoot: string
+  let config: Config
+  let storage: FileStorage
+
+  beforeEach(async () => {
+    projectRoot = await fs.mkdtemp(path.join(os.tmpdir(), 'filestorage-test-'))
+    config = new Config({ projectRoot })
+    storage = new FileStorage(config)
+  })
+
+  afterEach(async () => {
+    await fs.rm(projectRoot, { recursive: true, force: true })
+  })
+
+  describe('constructor', () => {
+    it('initializes with default configuration when instantiated without parameters', () => {
+      const defaultStorage = new FileStorage()
+
+      expect(defaultStorage).toBeDefined()
+      expect(defaultStorage).toBeInstanceOf(FileStorage)
+    })
+
+    it('should accept a Config instance', async () => {
+      await storage.saveTest('test content')
+      const retrieved = await storage.getTest()
+      expect(retrieved).toBe('test content')
+    })
+  })
+
+  it('creates directory if it does not exist', async () => {
+    const newProjectRoot = path.join(projectRoot, 'new-project')
+    const nonExistentPath = path.join(
+      newProjectRoot,
+      ...DEFAULT_DATA_DIR.split('/')
+    )
+    const customConfig = new Config({ projectRoot: newProjectRoot })
+    const customStorage = new FileStorage(customConfig)
+
+    await expect(fs.access(nonExistentPath)).rejects.toThrow()
+
+    await customStorage.saveTest('content')
+
+    await expect(fs.access(nonExistentPath)).resolves.toBeUndefined()
+  })
+
+  describe('save and get operations', () => {
+    it('saves and retrieves test content', async () => {
+      await storage.saveTest('test content')
+
+      const retrieved = await storage.getTest()
+      expect(retrieved).toBe('test content')
+    })
+
+    it('saves and retrieves todo content', async () => {
+      await storage.saveTodo('todo content')
+
+      const retrieved = await storage.getTodo()
+      expect(retrieved).toBe('todo content')
+    })
+
+    it('saves and retrieves modifications content', async () => {
+      await storage.saveModifications('modifications content')
+
+      const retrieved = await storage.getModifications()
+      expect(retrieved).toBe('modifications content')
+    })
+  })
+})

package/project-skills/tdd-guard/src/storage/FileStorage.ts

@@ -0,0 +1,108 @@
+import { Storage, TRANSIENT_DATA } from './Storage'
+import { Config } from '../config/Config'
+import fs from 'fs/promises'
+
+export class FileStorage implements Storage {
+  private readonly config: Config
+  private readonly filePaths: Record<string, string>
+
+  constructor(config?: Config) {
+    this.config = config ?? new Config()
+    this.filePaths = {
+      test: this.config.testResultsFilePath,
+      todo: this.config.todosFilePath,
+      modifications: this.config.modificationsFilePath,
+      lint: this.config.lintFilePath,
+      config: this.config.configFilePath,
+      instructions: this.config.instructionsFilePath,
+    }
+  }
+
+  private async ensureDirectory(): Promise<void> {
+    await fs.mkdir(this.config.dataDir, { recursive: true })
+  }
+
+  private async save(type: string, content: string): Promise<void> {
+    await this.ensureDirectory()
+    await fs.writeFile(this.filePaths[type], content)
+  }
+
+  private async get(type: string): Promise<string | null> {
+    try {
+      return await fs.readFile(this.filePaths[type], 'utf-8')
+    } catch {
+      return null
+    }
+  }
+
+  async saveTest(content: string): Promise<void> {
+    await this.save('test', content)
+  }
+
+  async saveTodo(content: string): Promise<void> {
+    await this.save('todo', content)
+  }
+
+  async saveModifications(content: string): Promise<void> {
+    await this.save('modifications', content)
+  }
+
+  async saveLint(content: string): Promise<void> {
+    await this.save('lint', content)
+  }
+
+  async saveConfig(content: string): Promise<void> {
+    await this.save('config', content)
+  }
+
+  async saveInstructions(content: string): Promise<void> {
+    await this.save('instructions', content)
+  }
+
+  async getTest(): Promise<string | null> {
+    return this.get('test')
+  }
+
+  async getTodo(): Promise<string | null> {
+    return this.get('todo')
+  }
+
+  async getModifications(): Promise<string | null> {
+    return this.get('modifications')
+  }
+
+  async getLint(): Promise<string | null> {
+    return this.get('lint')
+  }
+
+  async getConfig(): Promise<string | null> {
+    return this.get('config')
+  }
+
+  async getInstructions(): Promise<string | null> {
+    return this.get('instructions')
+  }
+
+  async clearTransientData(): Promise<void> {
+    await Promise.all(
+      TRANSIENT_DATA.map((fileType) =>
+        this.deleteFileIfExists(this.filePaths[fileType])
+      )
+    )
+  }
+
+  private async deleteFileIfExists(filePath: string): Promise<void> {
+    try {
+      await fs.unlink(filePath)
+    } catch (error) {
+      // Only ignore ENOENT errors (file not found)
+      if (
+        error instanceof Error &&
+        'code' in error &&
+        error.code !== 'ENOENT'
+      ) {
+        throw error
+      }
+    }
+  }
+}

package/project-skills/tdd-guard/src/storage/MemoryStorage.ts

@@ -0,0 +1,57 @@
+import { Storage, TRANSIENT_DATA } from './Storage'
+
+export class MemoryStorage implements Storage {
+  private readonly store = new Map<string, string>()
+
+  async saveTest(content: string): Promise<void> {
+    this.store.set('test', content)
+  }
+
+  async saveTodo(content: string): Promise<void> {
+    this.store.set('todo', content)
+  }
+
+  async saveModifications(content: string): Promise<void> {
+    this.store.set('modifications', content)
+  }
+
+  async saveLint(content: string): Promise<void> {
+    this.store.set('lint', content)
+  }
+
+  async saveConfig(content: string): Promise<void> {
+    this.store.set('config', content)
+  }
+
+  async saveInstructions(content: string): Promise<void> {
+    this.store.set('instructions', content)
+  }
+
+  async getTest(): Promise<string | null> {
+    return this.store.get('test') ?? null
+  }
+
+  async getTodo(): Promise<string | null> {
+    return this.store.get('todo') ?? null
+  }
+
+  async getModifications(): Promise<string | null> {
+    return this.store.get('modifications') ?? null
+  }
+
+  async getLint(): Promise<string | null> {
+    return this.store.get('lint') ?? null
+  }
+
+  async getConfig(): Promise<string | null> {
+    return this.store.get('config') ?? null
+  }
+
+  async getInstructions(): Promise<string | null> {
+    return this.store.get('instructions') ?? null
+  }
+
+  async clearTransientData(): Promise<void> {
+    TRANSIENT_DATA.forEach((key) => this.store.delete(key))
+  }
+}