xtrm-tools 2.2.0 → 2.4.0

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

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

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

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

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

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

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

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

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