xtrm-tools 2.3.0 → 2.4.0

package/project-skills/tdd-guard/src/linters/golangci/GolangciLint.test.ts

@@ -1,170 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'vitest'
-import { GolangciLint, buildArgs } from './GolangciLint'
-import { join } from 'path'
-import { hasRules, issuesFromFile } from '../../../test/utils/assertions'
-
-// Test artifacts directory - defined once for reuse
-const artifactsDir = join(process.cwd(), 'test', 'artifacts', 'go')
-const configPath = join(artifactsDir, '.golangci.yml')
-const withIssuesDir = join(artifactsDir, 'with-issues')
-const withoutIssuesDir = join(artifactsDir, 'without-issues')
-
-describe('GolangciLint', () => {
-  let linter: GolangciLint
-
-  beforeEach(() => {
-    linter = new GolangciLint()
-  })
-
-  describe('basic functionality', () => {
-    test('can be instantiated', () => {
-      expect(linter).toBeDefined()
-    })
-
-    test('implements Linter interface with lint method', async () => {
-      const result = await linter.lint([])
-
-      expect(result).toBeDefined()
-      expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-    })
-
-    test('returns the file paths that were passed in', async () => {
-      const filePaths = ['main.go', 'pkg/handler.go']
-      const result = await linter.lint(filePaths)
-
-      expect(result.files).toEqual(filePaths)
-    })
-  })
-
-  describe('linting behavior', () => {
-    let originalCwd: string
-
-    beforeEach(() => {
-      originalCwd = process.cwd()
-      process.chdir(withIssuesDir)
-    })
-
-    afterEach(() => {
-      process.chdir(originalCwd)
-    })
-
-    test('detects issues in file with lint problems', async () => {
-      const filePath = join(withIssuesDir, 'file-with-issues.go')
-      const result = await linter.lint([filePath], configPath)
-
-      expect(result.issues.length).toBeGreaterThan(0)
-      expect(result.errorCount).toBeGreaterThan(0)
-
-      // Check for specific rules that should be detected
-      const expectedRules = ['typecheck']
-      const ruleResults = hasRules(result.issues, expectedRules)
-
-      ruleResults.forEach((ruleExists) => {
-        expect(ruleExists).toBe(true)
-      })
-    })
-
-    test('returns specific golangci-lint message for undefined variable', async () => {
-      const filePath = join(withIssuesDir, 'file-with-issues.go')
-      const result = await linter.lint([filePath])
-
-      const undefinedVarIssue = result.issues.find((issue) =>
-        issue.message.includes('undefined: messag')
-      )
-      expect(undefinedVarIssue).toMatchObject({
-        rule: 'typecheck',
-        message: expect.stringContaining('undefined: messag'),
-      })
-    })
-
-    test('returns no issues for clean Go file', async () => {
-      const filePath = join(withoutIssuesDir, 'file-without-issues.go')
-      const result = await linter.lint([filePath])
-
-      expect(result.issues.length).toBe(0)
-      expect(result.errorCount).toBe(0)
-    })
-
-    test('returns exactly 2 issues for problematic file', async () => {
-      const filePath = join(withIssuesDir, 'file-with-issues.go')
-      const result = await linter.lint([filePath])
-
-      expect(result.issues.length).toBe(2)
-      expect(result.errorCount).toBe(2)
-    })
-
-    test('returns different results for different files', async () => {
-      const problemFile = join(withIssuesDir, 'file-with-issues.go')
-      const cleanFile = join(withoutIssuesDir, 'file-without-issues.go')
-
-      const problemResult = await linter.lint([problemFile])
-      const cleanResult = await linter.lint([cleanFile])
-
-      expect(problemResult.issues.length).toBeGreaterThan(0)
-      expect(cleanResult.issues.length).toBe(0)
-    })
-
-    test('processes individual files correctly', async () => {
-      const problemFile = join(withIssuesDir, 'file-with-issues.go')
-      const result = await linter.lint([problemFile])
-
-      expect(result.files).toEqual([problemFile])
-      expect(result.issues.length).toBeGreaterThan(0)
-
-      // All issues should be from the problematic file
-      const problemFileIssues = issuesFromFile(
-        result.issues,
-        'file-with-issues.go'
-      )
-      expect(problemFileIssues.length).toBeGreaterThan(0)
-    })
-  })
-
-  describe('directory-based linting', () => {
-    test('should build args for directory-based linting with current directory', () => {
-      const args = buildArgs([], configPath)
-
-      // Should contain basic golangci-lint arguments
-      expect(args).toContain('run')
-      expect(args).toContain('--output.json.path=stdout')
-      expect(args).toContain('--config')
-      expect(args).toContain(configPath)
-
-      // With empty filePaths, should have no directories in args
-      expect(args).not.toContain('.')
-      expect(args).toContain('--path-mode=abs')
-    })
-  })
-
-  describe('with files containing special characters', () => {
-    test.each([
-      ['spaces', 'src/my file with spaces.go'],
-      ['quotes', 'src/file"with"quotes.go'],
-      ['semicolons', 'src/file;name.go'],
-      ['backticks', 'src/file`with`backticks.go'],
-      ['dollar signs', 'src/file$with$dollar.go'],
-      ['pipes', 'src/file|with|pipes.go'],
-      ['ampersands', 'src/file&with&ampersands.go'],
-      ['parentheses', 'src/file(with)parentheses.go'],
-      ['command injection attempt', 'file.go"; cat /etc/passwd; echo "'],
-      ['newlines', 'src/file\nwith\nnewlines.go'],
-      ['tabs', 'src/file\twith\ttabs.go'],
-    ])('handles file paths with %s correctly', async (_, filePath) => {
-      const result = await linter.lint([filePath])
-
-      expect(result.files).toEqual([filePath])
-      expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-    })
-
-    test.each([
-      ['spaces', '/path with spaces/.golangci.yml'],
-      ['quotes', '/path"with"quotes/.golangci.yml'],
-      ['special chars', '/path;with&special|chars/.golangci.yml'],
-    ])('handles config paths with %s correctly', async (_, configFilePath) => {
-      const result = await linter.lint(['main.go'], configFilePath)
-
-      expect(result.files).toEqual(['main.go'])
-      expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-    })
-  })
-})

package/project-skills/tdd-guard/src/linters/golangci/GolangciLint.ts

@@ -1,148 +0,0 @@
-import {
-  LintResult,
-  LintIssue,
-  GolangciLintIssue,
-  GolangciLintResult,
-} from '../../contracts/schemas/lintSchemas'
-import { execFile } from 'child_process'
-import { promisify } from 'util'
-import { dirname } from 'path'
-import { Linter } from '../Linter'
-
-const execFileAsync = promisify(execFile)
-
-export class GolangciLint implements Linter {
-  async lint(filePaths: string[], configPath?: string): Promise<LintResult> {
-    const timestamp = new Date().toISOString()
-    const args = buildArgs(filePaths, configPath)
-
-    try {
-      // golangci-lint exits with non-zero code when issues are found
-      await execFileAsync('golangci-lint', args)
-      return createLintData(timestamp, filePaths, [])
-    } catch (error) {
-      if (!isExecError(error)) throw error
-
-      const results = parseResults(error.stdout)
-      return createLintData(timestamp, filePaths, results)
-    }
-  }
-}
-
-// Helper functions
-export const buildArgs = (
-  filePaths: string[],
-  configPath?: string
-): string[] => {
-  const args = ['run', '--output.json.path=stdout', '--path-mode=abs']
-
-  if (configPath) {
-    args.push('--config', configPath)
-  } else {
-    args.push('--no-config')
-  }
-
-  // Convert file paths to unique directories since golangci-lint runs on directories
-  const directories = [...new Set(filePaths.map((file) => dirname(file)))]
-  args.push(...directories)
-
-  return args
-}
-
-const isExecError = (error: unknown): error is Error & { stdout?: string } =>
-  error !== null && typeof error === 'object' && 'stdout' in error
-
-// Parse golangci-lint JSON output - only first line contains JSON, rest is summary
-const parseResults = (stdout?: string): GolangciLintIssue[] => {
-  try {
-    if (stdout === undefined || stdout === '') {
-      return []
-    }
-
-    const lines = stdout.split('\n')
-    const jsonLine = lines[0]
-    if (jsonLine.trim() === '') {
-      return []
-    }
-
-    const parsed: GolangciLintResult = JSON.parse(jsonLine)
-    return parsed.Issues ?? []
-  } catch {
-    return []
-  }
-}
-
-const createLintData = (
-  timestamp: string,
-  files: string[],
-  results: GolangciLintIssue[]
-): LintResult => {
-  const issues = results.flatMap(toIssue)
-  return {
-    timestamp,
-    files,
-    issues,
-    errorCount: countBySeverity(issues, 'error'),
-    warningCount: countBySeverity(issues, 'warning'),
-  }
-}
-
-const toIssue = (issue: GolangciLintIssue): LintIssue[] => {
-  // Check if this contains multiple issues in the Text field
-  if (issue.Text.includes('\n') && issue.Text.includes('.go:')) {
-    // Parse multi-line text to extract individual issues
-    const lines = issue.Text.split('\n').slice(1) // Skip module name line
-    return lines
-      .filter((line) => line.includes('.go:'))
-      .map((line) => parseIssueLine(line, issue.FromLinter))
-      .filter((parsedIssue): parsedIssue is LintIssue => parsedIssue !== null)
-  }
-
-  // Single issue
-  return [
-    {
-      file: issue.Pos.Filename,
-      line: issue.Pos.Line,
-      column: issue.Pos.Column,
-      severity: 'error' as const,
-      message: issue.Text,
-      rule: issue.FromLinter,
-    },
-  ]
-}
-
-const parseIssueLine = (line: string, linter: string): LintIssue | null => {
-  // Parse format: "./file-with-issues.go:8:2: declared and not used: message"
-  const parts = line.split(':')
-  const MIN_PARTS = 4 // filename:line:column:message
-
-  if (parts.length < MIN_PARTS || !line.includes('.go:')) return null
-
-  const filename = parts[0]
-  const lineStr = parts[1]
-  const columnStr = parts[2]
-  const MESSAGE_START_INDEX = 3
-  const message = parts.slice(MESSAGE_START_INDEX).join(':').trim()
-
-  if (
-    !filename.endsWith('.go') ||
-    !/^\d+$/.test(lineStr) ||
-    !/^\d+$/.test(columnStr)
-  ) {
-    return null
-  }
-
-  return {
-    file: filename,
-    line: parseInt(lineStr, 10),
-    column: parseInt(columnStr, 10),
-    severity: 'error' as const,
-    message,
-    rule: linter,
-  }
-}
-
-const countBySeverity = (
-  issues: LintIssue[],
-  severity: 'error' | 'warning'
-): number => issues.filter((i) => i.severity === severity).length

package/project-skills/tdd-guard/src/processors/index.ts

@@ -1 +0,0 @@
-export { TestResultsProcessor } from './testResults/TestResultsProcessor'

package/project-skills/tdd-guard/src/processors/lintProcessor.ts

@@ -1,77 +0,0 @@
-import { ProcessedLintData } from '../contracts/types/Context'
-import { LintData } from '../contracts/schemas/lintSchemas'
-
-/**
- * Processes lint data into a presentable format for validation context
- */
-export function processLintData(lintData?: LintData): ProcessedLintData {
-  if (!lintData) {
-    return {
-      hasIssues: false,
-      summary: 'No lint data available',
-      issuesByFile: new Map(),
-      totalIssues: 0,
-      errorCount: 0,
-      warningCount: 0,
-    }
-  }
-
-  const hasIssues = lintData.errorCount > 0 || lintData.warningCount > 0
-  const totalIssues = lintData.errorCount + lintData.warningCount
-
-  if (!hasIssues) {
-    return {
-      hasIssues: false,
-      summary: 'No lint issues found',
-      issuesByFile: new Map(),
-      totalIssues: 0,
-      errorCount: 0,
-      warningCount: 0,
-    }
-  }
-
-  // Group issues by file
-  const issuesByFile = new Map<string, string[]>()
-  for (const issue of lintData.issues) {
-    if (!issuesByFile.has(issue.file)) {
-      issuesByFile.set(issue.file, [])
-    }
-
-    const ruleInfo = issue.rule ? ` (${issue.rule})` : ''
-    const formattedIssue = `  Line ${issue.line}:${issue.column} - ${issue.severity}: ${issue.message}${ruleInfo}`
-    issuesByFile.get(issue.file)!.push(formattedIssue)
-  }
-
-  const summary = `${totalIssues} lint ${totalIssues === 1 ? 'issue' : 'issues'} found (${lintData.errorCount} ${lintData.errorCount === 1 ? 'error' : 'errors'}, ${lintData.warningCount} ${lintData.warningCount === 1 ? 'warning' : 'warnings'})`
-
-  return {
-    hasIssues: true,
-    summary,
-    issuesByFile,
-    totalIssues,
-    errorCount: lintData.errorCount,
-    warningCount: lintData.warningCount,
-  }
-}
-
-/**
- * Formats processed lint data as a readable string for AI context
- */
-export function formatLintDataForContext(
-  processedLint: ProcessedLintData
-): string {
-  if (!processedLint.hasIssues) {
-    return processedLint.summary
-  }
-
-  let formatted = `Code Quality Status: ${processedLint.summary}\n`
-
-  if (processedLint.issuesByFile.size > 0) {
-    formatted += '\nLint Issues by File:\n'
-    for (const [file, issues] of processedLint.issuesByFile) {
-      formatted += `\n${file}:\n${issues.join('\n')}\n`
-    }
-  }
-
-  return formatted.trim()
-}

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

@@ -1,303 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest'
-import { TestResultsProcessor } from './TestResultsProcessor'
-import { testData } from '../../../test/utils'
-
-describe('TestResultsProcessor', () => {
-  it('should format empty test results', () => {
-    const processor = new TestResultsProcessor()
-    const result = processor.process('{}')
-
-    expect(result).toBe('No test results found.')
-  })
-
-  it('should handle invalid JSON gracefully', () => {
-    const processor = new TestResultsProcessor()
-    const result = processor.process('invalid json')
-
-    expect(result).toBe('Invalid JSON format.')
-  })
-
-  it('should handle invalid test result format', () => {
-    const processor = new TestResultsProcessor()
-    const result = processor.process('{"testModules": "not an array"}')
-
-    expect(result).toBe('Invalid test result format.')
-  })
-
-  describe('scenarios', () => {
-    it('should format all error messages for a failing test', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = {
-        testModules: [
-          {
-            moduleId: '/src/example.test.ts',
-            tests: [
-              {
-                name: 'CompilationError',
-                fullName: 'CompilationError',
-                state: 'failed',
-                errors: [
-                  { message: 'example.go:9:8: undefined: NewFormatter' },
-                  { message: 'example.go:10:12: undefined: TestEvent' },
-                  { message: 'example.go:11:5: undefined: SomeOtherThing' },
-                ],
-              },
-            ],
-          },
-        ],
-        reason: 'failed',
-      }
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      // Check that key elements are present
-      expect(result).toContain('/src/example.test.ts')
-      expect(result).toContain('CompilationError')
-      expect(result).toContain('example.go')
-      expect(result).toContain('undefined: NewFormatter')
-      expect(result).toContain('undefined: TestEvent')
-      expect(result).toContain('undefined: SomeOtherThing')
-
-      // Check summary
-      expect(result).toContain('Test Files')
-      expect(result).toContain('1 failed')
-      expect(result).toContain('Tests')
-      expect(result).toContain('1 failed')
-    })
-
-    it('2 passing tests in the same file', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.passingTestResults()
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      const expected = ` ✓ /src/example.test.ts (2 tests) 0ms
-
- Test Files  1 passed (1)
-      Tests  2 passed (2)
-`
-
-      expect(result).toBe(expected)
-    })
-
-    it('2 failing tests in the same file', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.multipleFailedTestResults()
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      const expected = ` ❯ /src/calculator.test.ts (2 tests | 2 failed) 0ms
-   × Calculator > should add two numbers 0ms
-     → expected 5 to be 6
-   × Calculator > should multiply two numbers 0ms
-     → expected 12 to be 15
-
- Test Files  1 failed (1)
-      Tests  2 failed (2)
-`
-
-      expect(result).toBe(expected)
-    })
-
-    it('1 passing and 1 failing test in the same file', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.mixedTestResults()
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      const expected = ` ❯ /src/calculator.test.ts (2 tests | 1 failed) 0ms
-   ✓ Calculator > should add two numbers 0ms
-   × Calculator > should multiply two numbers 0ms
-     → expected 12 to be 15
-
- Test Files  1 failed | 0 passed (1)
-      Tests  1 failed | 1 passed (2)
-`
-
-      expect(result).toBe(expected)
-    })
-
-    it('2 files with a passing and a failing test pair in each', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.multipleModulesTestResults()
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      const expected = ` ❯ /src/calculator.test.ts (2 tests | 1 failed) 0ms
-   ✓ Calculator > should add two numbers 0ms
-   × Calculator > should multiply two numbers 0ms
-     → expected 12 to be 15
- ❯ /src/utils/formatter.test.ts (2 tests | 1 failed) 0ms
-   ✓ Formatter > should format currency 0ms
-   × Formatter > should format date 0ms
-     → expected "2024-01-01" to be "01/01/2024"
-
- Test Files  2 failed | 0 passed (2)
-      Tests  2 failed | 2 passed (4)
-`
-
-      expect(result).toBe(expected)
-    })
-  })
-
-  it('should handle pytest format with passing tests', () => {
-    const processor = new TestResultsProcessor()
-    const pytestResults = {
-      testModules: [
-        {
-          moduleId: 'test_example.py',
-          tests: [
-            {
-              name: 'test_addition',
-              fullName: 'test_example.py::test_addition',
-              state: 'passed',
-            },
-          ],
-        },
-      ],
-    }
-
-    const result = processor.process(JSON.stringify(pytestResults))
-
-    const expected = ` ✓ test_example.py (1 tests) 0ms
-
- Test Files  1 passed (1)
-      Tests  1 passed (1)
-`
-
-    expect(result).toBe(expected)
-  })
-
-  describe('formats unhandled errors separately from test results', () => {
-    let processor: TestResultsProcessor
-    let result: string
-
-    beforeEach(() => {
-      processor = new TestResultsProcessor()
-      const testResults = testData.createTestResults({
-        testModules: [testData.createTestModule()],
-        unhandledErrors: [testData.createUnhandledError()],
-      })
-
-      result = processor.process(JSON.stringify(testResults))
-    })
-
-    it('shows module as passed with 0 tests', () => {
-      expect(result).toContain('✓ /src/example.test.ts (0 tests)')
-    })
-
-    it('displays unhandled errors section', () => {
-      expect(result).toContain('Unhandled Errors:')
-    })
-
-    it('shows error name and message', () => {
-      expect(result).toContain('× Error: Cannot find module "./helpers"')
-    })
-
-    it('includes stack trace', () => {
-      expect(result).toContain('Stack:')
-      expect(result).toContain('imported from')
-    })
-
-    it('summary shows passed test file', () => {
-      expect(result).toContain('Test Files  1 passed (1)')
-    })
-
-    it('summary shows 0 tests', () => {
-      expect(result).toContain('Tests  0 passed (0)')
-    })
-  })
-
-  describe('handles test run end reason', () => {
-    it('displays reason explanation when test run failed with import error', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.createTestResults({
-        testModules: [testData.createTestModule()],
-        unhandledErrors: [testData.createUnhandledError()],
-        reason: 'failed',
-      })
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      expect(result).toContain(
-        'Test run failed - This is likely when an imported module can not be found'
-      )
-    })
-
-    it('does not display import error explanation when tests fail for other reasons', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.createTestResults({
-        testModules: [
-          testData.createTestModule({
-            moduleId: '/src/calculator.test.ts',
-            tests: [
-              testData.createTest({
-                name: 'should add two numbers',
-                fullName: 'Calculator > should add two numbers',
-                state: 'failed',
-                errors: [
-                  testData.createTestError({
-                    message: 'expected 5 to be 6',
-                  }),
-                ],
-              }),
-            ],
-          }),
-        ],
-        unhandledErrors: [],
-        reason: 'failed',
-      })
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      expect(result).not.toContain(
-        'This is likely when an imported module can not be found'
-      )
-      expect(result).toContain('expected 5 to be 6')
-    })
-
-    it('displays reason explanation when test run failed with no tests collected', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.createTestResults({
-        testModules: [testData.createTestModule()],
-        reason: 'failed',
-      })
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      expect(result).toContain(
-        'Test run failed - This is likely when an imported module can not be found'
-      )
-    })
-
-    it('shows module as failed when test run failed with no tests', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.createTestResults({
-        testModules: [
-          testData.createTestModule({
-            moduleId: '/src/linters/eslint/helpers.test.ts',
-          }),
-        ],
-        reason: 'failed',
-      })
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      expect(result).toContain(
-        '❯ /src/linters/eslint/helpers.test.ts (0 tests | 0 failed) 0ms'
-      )
-    })
-
-    it('counts module as failed in summary when test run failed with no tests', () => {
-      const processor = new TestResultsProcessor()
-      const testResults = testData.createTestResults({
-        testModules: [testData.createTestModule()],
-        reason: 'failed',
-      })
-
-      const result = processor.process(JSON.stringify(testResults))
-
-      expect(result).toContain('Test Files  1 failed (1)')
-    })
-  })
-})