xtrm-tools 2.2.0 → 2.4.0

package/project-skills/tdd-guard/src/validation/validator.test.ts

@@ -1,268 +0,0 @@
-import { Context } from '../contracts/types/Context'
-import { ValidationResult } from '../contracts/types/ValidationResult'
-import { IModelClient } from '../contracts/types/ModelClient'
-import { describe, test, expect, vi, beforeEach } from 'vitest'
-import { validator } from './validator'
-import { generateDynamicContext } from './context/context'
-import { testData } from '@testUtils'
-
-vi.mock('./context/context', () => ({
-  generateDynamicContext: vi.fn(),
-}))
-
-describe('validator with mock model', () => {
-  const mockGenerateDynamicContext = vi.mocked(generateDynamicContext)
-
-  beforeEach(() => {
-    vi.clearAllMocks()
-  })
-
-  describe('simplified interface', () => {
-    test('should only pass prompt to model client without context', async () => {
-      const { result, mockModelClient, context } = await runValidator(
-        JSON.stringify({ decision: null, reason: 'ok' }),
-        { prompt: 'complete prompt with all context included' }
-      )
-
-      expect(mockGenerateDynamicContext).toHaveBeenCalledWith(context)
-      // Should only pass the prompt, not the context
-      expect(mockModelClient.ask).toHaveBeenCalledWith(
-        'complete prompt with all context included'
-      )
-      expect(result).toEqual({
-        decision: undefined,
-        reason: 'ok',
-      })
-    })
-  })
-
-  describe('JSON extraction from model responses', () => {
-    const BLOCK_JSON = '{"decision": "block", "reason": "TDD violation"}'
-    const PASS_JSON = '{"decision": null, "reason": "ok"}'
-
-    const testCases = [
-      {
-        name: 'should extract JSON from markdown code blocks',
-        modelResponse: `\`\`\`json\n${BLOCK_JSON}\n\`\`\``,
-        expected: { decision: 'block', reason: 'TDD violation' },
-      },
-      {
-        name: 'should handle JSON with extra whitespace in code blocks',
-        modelResponse: `\`\`\`json  \n\n  ${PASS_JSON}  \n\n\`\`\``,
-        expected: { decision: undefined, reason: 'ok' },
-      },
-      {
-        name: 'should parse raw JSON when no code block present',
-        modelResponse: PASS_JSON,
-        expected: { decision: undefined, reason: 'ok' },
-      },
-      {
-        name: 'should extract JSON from response with surrounding text',
-        modelResponse: `Here is my analysis:\n\`\`\`json\n${BLOCK_JSON}\n\`\`\`\nThat concludes the review.`,
-        expected: { decision: 'block', reason: 'TDD violation' },
-      },
-      {
-        name: 'should handle fence blocks without language specification',
-        modelResponse: `\`\`\`\n${PASS_JSON}\n\`\`\``,
-        expected: { decision: undefined, reason: 'ok' },
-      },
-      {
-        name: 'should ignore fence blocks with txt language',
-        modelResponse: `\`\`\`txt\nSome analysis text\n\`\`\`\n${PASS_JSON}`,
-        expected: { decision: undefined, reason: 'ok' },
-      },
-      {
-        name: 'should extract the last JSON fence block when multiple exist',
-        modelResponse: `First block:\n\`\`\`json\n${BLOCK_JSON}\n\`\`\`\nSecond block:\n\`\`\`json\n${PASS_JSON}\n\`\`\``,
-        expected: { decision: undefined, reason: 'ok' },
-      },
-      {
-        name: 'should convert null decision to undefined',
-        modelResponse: '{"decision": null, "reason": "No issues found"}',
-        expected: { decision: undefined, reason: 'No issues found' },
-      },
-      {
-        name: 'should extract JSON from response with detailed explanation before JSON',
-        modelResponse: `Analysis paragraph one explaining the issue.
-
-Analysis paragraph two with more details.
-
-{
-  "decision": "block",
-  "reason": "Multiple test addition violation - adding 2 new tests simultaneously instead of following TDD discipline of one test at a time"
-}`,
-        expected: {
-          decision: 'block',
-          reason:
-            'Multiple test addition violation - adding 2 new tests simultaneously instead of following TDD discipline of one test at a time',
-        },
-      },
-      {
-        name: 'should extract JSON with line break before opening brace',
-        modelResponse: `Analysis text that gets cut off mid-sentence because it's too lo...
-{
-  "decision": "block",
-  "reason": "Multiple test addition violation - adding 2 new tests simultaneously instead of following TDD discipline of one test at a time"
-}`,
-        expected: {
-          decision: 'block',
-          reason:
-            'Multiple test addition violation - adding 2 new tests simultaneously instead of following TDD discipline of one test at a time',
-        },
-      },
-      {
-        name: 'should extract JSON when analyzing constructor error',
-        modelResponse: `Analysis with code blocks:
-
-\`\`\`
-Calculator is not a constructor
-\`\`\`
-
-More analysis after the error message.
-
-{
-  "decision": "block",
-  "reason": "Over-implementation: Test fails with 'Calculator is not a constructor' but you're adding both the class AND the add method. Should only create empty class first, then run test again to get proper failure for the add method."
-}`,
-        expected: {
-          decision: 'block',
-          reason:
-            "Over-implementation: Test fails with 'Calculator is not a constructor' but you're adding both the class AND the add method. Should only create empty class first, then run test again to get proper failure for the add method.",
-        },
-      },
-      {
-        name: 'should extract JSON when analyzing not defined error with typescript code',
-        modelResponse: `Analysis with TypeScript code block:
-
-\`\`\`typescript
-export class Calculator {
-  add(a: number, b: number): number {
-    return a + b;
-  }
-}
-\`\`\`
-
-Analysis continues after the code block.
-
-{
-  "decision": "block",
-  "reason": "Over-implementation violation. Test fails with 'Calculator is not defined' but implementation adds both class AND add method. Should only create empty class first, then run test to get next failure."
-}`,
-        expected: {
-          decision: 'block',
-          reason:
-            "Over-implementation violation. Test fails with 'Calculator is not defined' but implementation adds both class AND add method. Should only create empty class first, then run test to get next failure.",
-        },
-      },
-      {
-        name: 'should extract JSON when model provides extensive analysis before decision',
-        modelResponse: `Extensive analysis with lists:
-
-1. First point about the issue
-2. Second point with more detail
-3. Third point explaining the problem
-
-This violates TDD principles as explained in the numbered list above.
-
-{
-  "decision": "block",
-  "reason": "Multiple test addition violation - adding 2 new tests simultaneously instead of following TDD discipline of one test at a time"
-}`,
-        expected: {
-          decision: 'block',
-          reason:
-            'Multiple test addition violation - adding 2 new tests simultaneously instead of following TDD discipline of one test at a time',
-        },
-      },
-    ]
-
-    testCases.forEach(({ name, modelResponse, expected }) => {
-      test(name, async () => {
-        const { result } = await runValidator(modelResponse)
-        expect(result).toEqual(expected)
-      })
-    })
-  })
-
-  describe('prompt generation for different tools', () => {
-    test('should send correct prompt for Edit operation', async () => {
-      const { result, mockModelClient, context } = await runValidator(
-        JSON.stringify({ decision: null, reason: 'ok' }),
-        { prompt: 'mocked prompt with Edit instructions' }
-      )
-
-      expect(mockGenerateDynamicContext).toHaveBeenCalledWith(context)
-      expect(mockModelClient.ask).toHaveBeenCalledWith(
-        'mocked prompt with Edit instructions'
-      )
-      expect(result).toEqual({
-        decision: undefined,
-        reason: 'ok',
-      })
-    })
-  })
-
-  describe('error handling', () => {
-    test('should block when model client throws error', async () => {
-      const { result } = await runValidator(
-        new Error('Command failed: claude not found')
-      )
-
-      expect(result.decision).toBe('block')
-      expect(result.reason).toContain('Error during validation')
-      expect(result.reason).toContain('Command failed: claude not found')
-    })
-
-    test('should block when model returns invalid JSON', async () => {
-      const { result } = await runValidator(
-        `\`\`\`json\ninvalid json content\n\`\`\``
-      )
-
-      expect(result.decision).toBe('block')
-      expect(result.reason).toContain('Error during validation')
-    })
-
-    test('should provide special message when model returns no response', async () => {
-      const { result } = await runValidator('')
-
-      expect(result.decision).toBe('block')
-      expect(result.reason).not.toContain('Error during validation')
-      expect(result.reason).toBe('No response from model, try again')
-    })
-  })
-
-  // Test helper
-  async function runValidator(
-    modelResponse: string | Error,
-    options?: {
-      contextOverrides?: Partial<Context>
-      prompt?: string
-    }
-  ): Promise<{
-    result: ValidationResult
-    mockModelClient: IModelClient
-    context: Context
-  }> {
-    const mockModelClient: IModelClient = {
-      ask:
-        modelResponse instanceof Error
-          ? vi.fn().mockRejectedValue(modelResponse)
-          : vi.fn().mockResolvedValue(modelResponse),
-    }
-
-    const context: Context = {
-      modifications: JSON.stringify(testData.editOperation()),
-      ...options?.contextOverrides,
-    }
-
-    mockGenerateDynamicContext.mockReturnValue(options?.prompt ?? 'test prompt')
-
-    const result = await validator(context, mockModelClient)
-
-    return {
-      result,
-      mockModelClient,
-      context,
-    }
-  }
-})

package/project-skills/tdd-guard/src/validation/validator.ts

@@ -1,159 +0,0 @@
-import { ValidationResult } from '../contracts/types/ValidationResult'
-import { Context } from '../contracts/types/Context'
-import { IModelClient } from '../contracts/types/ModelClient'
-import { ClaudeCli } from './models/ClaudeCli'
-import { generateDynamicContext } from './context/context'
-
-interface ModelResponseJson {
-  decision: 'block' | 'approve' | null
-  reason: string
-}
-
-export async function validator(
-  context: Context,
-  modelClient: IModelClient = new ClaudeCli()
-): Promise<ValidationResult> {
-  try {
-    const prompt = generateDynamicContext(context)
-    const response = await modelClient.ask(prompt)
-    return parseModelResponse(response)
-  } catch (error) {
-    const errorMessage =
-      error instanceof Error ? error.message : 'Unknown error'
-    const reason =
-      errorMessage === 'No response from model'
-        ? 'No response from model, try again'
-        : `Error during validation: ${errorMessage}`
-
-    return {
-      decision: 'block',
-      reason,
-    }
-  }
-}
-
-function parseModelResponse(response: string): ValidationResult {
-  const jsonString = extractJsonString(response)
-  const parsed = JSON.parse(jsonString)
-  return normalizeValidationResult(parsed)
-}
-
-function extractJsonString(response: string): string {
-  // Handle undefined/null responses
-  if (!response) {
-    throw new Error('No response from model')
-  }
-
-  const jsonFromCodeBlock = extractFromJsonCodeBlock(response)
-  if (jsonFromCodeBlock) {
-    return jsonFromCodeBlock
-  }
-
-  const jsonFromGenericBlock = extractFromGenericCodeBlock(response)
-  if (jsonFromGenericBlock) {
-    return jsonFromGenericBlock
-  }
-
-  // Try to extract plain JSON from text
-  const plainJson = extractPlainJson(response)
-  if (plainJson) {
-    return plainJson
-  }
-
-  return response
-}
-
-function extractFromJsonCodeBlock(response: string): string | null {
-  // Find all json code blocks
-  const startPattern = '```json'
-  const endPattern = '```'
-  const blocks: string[] = []
-
-  let startIndex = 0
-  let blockStart = response.indexOf(startPattern, startIndex)
-
-  while (blockStart !== -1) {
-    const contentStart = blockStart + startPattern.length
-    const blockEnd = response.indexOf(endPattern, contentStart)
-    if (blockEnd === -1) break
-
-    const content = response.substring(contentStart, blockEnd).trim()
-    blocks.push(content)
-    startIndex = blockEnd + endPattern.length
-    blockStart = response.indexOf(startPattern, startIndex)
-  }
-
-  if (blocks.length > 0) {
-    return blocks[blocks.length - 1]
-  }
-
-  return null
-}
-
-function extractPlainJson(response: string): string | null {
-  // Simple regex to find JSON objects containing both "decision" and "reason" (in any order)
-  const pattern =
-    /\{[^{}]*"decision"[^{}]*"reason"[^{}]*}|\{[^{}]*"reason"[^{}]*"decision"[^{}]*}/g
-  const matches = response.match(pattern)
-
-  if (!matches) return null
-
-  // Return the last match (most likely the final decision)
-  const lastMatch = matches[matches.length - 1]
-
-  // Validate it's proper JSON
-  if (isValidJson(lastMatch)) {
-    return lastMatch
-  }
-
-  return null
-}
-
-function extractFromGenericCodeBlock(response: string): string | null {
-  const codeBlock = findCodeBlock(response)
-  if (!codeBlock) return null
-
-  const content = codeBlock.trim()
-  return isValidJson(content) ? content : null
-}
-
-function findCodeBlock(response: string): string | null {
-  const startPattern = '```'
-  const blockStart = response.indexOf(startPattern)
-  if (blockStart === -1) return null
-
-  const contentStart = skipWhitespace(
-    response,
-    blockStart + startPattern.length
-  )
-  const blockEnd = response.indexOf(startPattern, contentStart)
-  if (blockEnd === -1) return null
-
-  return response.substring(contentStart, blockEnd)
-}
-
-function skipWhitespace(text: string, startIndex: number): number {
-  let index = startIndex
-  while (index < text.length && /\s/.test(text[index])) {
-    index++
-  }
-  return index
-}
-
-function isValidJson(str: string): boolean {
-  try {
-    JSON.parse(str)
-    return true
-  } catch {
-    return false
-  }
-}
-
-function normalizeValidationResult(
-  parsed: ModelResponseJson
-): ValidationResult {
-  return {
-    decision: parsed.decision ?? undefined,
-    reason: parsed.reason,
-  }
-}

package/project-skills/tdd-guard/test/artifacts/go/.golangci.yml

@@ -1,6 +0,0 @@
-version: 2
-linters:
-  enable:
-    - govet
-    - errcheck
-    - ineffassign

package/project-skills/tdd-guard/test/artifacts/go/with-issues/file-with-issues.go

@@ -1,12 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-	result := 42
-	result = 24     // ineffassign: ineffectual assignment
-	message := "Hello"
-	
-	fmt.Println(result) // use result to avoid unused var error
-	fmt.Println(messag) // typecheck: undefined variable
-}

package/project-skills/tdd-guard/test/artifacts/go/with-issues/go.mod

@@ -1,3 +0,0 @@
-module tdd-guard-test/with-issues
-
-go 1.19

package/project-skills/tdd-guard/test/artifacts/go/without-issues/file-without-issues.go

@@ -1,7 +0,0 @@
-package main
-
-import "fmt"
-
-func main() {
-    fmt.Println("Hello, World!")
-}

package/project-skills/tdd-guard/test/artifacts/go/without-issues/go.mod

@@ -1,3 +0,0 @@
-module tdd-guard-test/without-issues
-
-go 1.19

package/project-skills/tdd-guard/test/artifacts/javascript/eslint.config.js

@@ -1,20 +0,0 @@
-module.exports = [
-  {
-    files: ['**/*.js'],
-    rules: {
-      'no-unused-vars': 'error',
-      'no-var': 'error',
-      'semi': ['error', 'always'],
-      'quotes': ['error', 'single'],
-      'no-duplicate-string': 'off',
-      'max-params': ['error', 5]
-    },
-    languageOptions: {
-      ecmaVersion: 2020,
-      sourceType: 'module'
-    }
-  },
-  {
-    ignores: ['node_modules/**', 'dist/**', 'coverage/**']
-  }
-];

package/project-skills/tdd-guard/test/artifacts/javascript/file-with-issues.js

@@ -1,12 +0,0 @@
-// This file has intentional lint issues for testing
-var unusedVariable = 5;
-console.log("hello")
-console.log("hello")
-console.log("hello")
-
-function tooManyParams(a, b, c, d, e, f) {
-  return a + b;
-}
-
-var x = 1
-var y = 2

package/project-skills/tdd-guard/test/artifacts/javascript/file-without-issues.js

@@ -1,10 +0,0 @@
-// This file has no lint issues
-const greeting = 'hello';
-console.log(greeting);
-
-function add(a, b) {
-  return a + b;
-}
-
-const result = add(1, 2);
-console.log(result);

package/project-skills/tdd-guard/test/hooks/fileTypeDetection.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { detectFileType } from '../../src/hooks/fileTypeDetection'
-
-describe('detectFileType', () => {
-  it('should detect Python files', () => {
-    const hookData = {
-      tool_input: {
-        file_path: 'src/calculator.py'
-      }
-    }
-    
-    const result = detectFileType(hookData)
-    expect(result).toBe('python')
-  })
-
-  it('should detect JavaScript files', () => {
-    const hookData = {
-      tool_input: {
-        file_path: 'src/calculator.js'
-      }
-    }
-    
-    const result = detectFileType(hookData)
-    expect(result).toBe('javascript')
-  })
-})

package/project-skills/tdd-guard/test/hooks/processHookData.fileType.test.ts

@@ -1,46 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { processHookData } from '../../src/hooks/processHookData'
-import { MemoryStorage } from '../../src/storage/MemoryStorage'
-
-describe('processHookData file type integration', () => {
-  it('should use pytest schema for Python files', async () => {
-    const storage = new MemoryStorage()
-    const pytestResults = {
-      testModules: [{
-        moduleId: 'test_example.py',
-        tests: [{
-          name: 'test_passing',
-          fullName: 'test_example.py::test_passing',
-          state: 'passed'
-        }]
-      }]
-    }
-    
-    await storage.saveTest(JSON.stringify(pytestResults))
-    
-    const hookData = {
-      hook_event_name: 'PreToolUse',
-      tool_input: { file_path: 'test_example.py' }
-    }
-    
-    const result = await processHookData(JSON.stringify(hookData), { storage })
-    
-    // Should not block when pytest results are valid for Python file
-    expect(result.decision).toBeUndefined()
-  })
-
-  it('should handle Python file when no test results exist', async () => {
-    const storage = new MemoryStorage()
-    // No test results stored
-    
-    const hookData = {
-      hook_event_name: 'PreToolUse',
-      tool_input: { file_path: 'calculator.py' }
-    }
-    
-    const result = await processHookData(JSON.stringify(hookData), { storage })
-    
-    // Should not block when no test results (allows initial implementation)
-    expect(result.decision).toBeUndefined()
-  })
-})

package/project-skills/tdd-guard/test/hooks/processHookData.python.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { processHookData } from '../../src/hooks/processHookData'
-import { MemoryStorage } from '../../src/storage/MemoryStorage'
-
-describe('processHookData python support', () => {
-  it('should handle pytest test results format', async () => {
-    const storage = new MemoryStorage()
-    const pytestResults = {
-      testModules: [
-        {
-          moduleId: 'test_example.py',
-          tests: [
-            {
-              name: 'test_passing',
-              fullName: 'test_example.py::test_passing',
-              state: 'passed'
-            }
-          ]
-        }
-      ]
-    }
-    
-    await storage.saveTest(JSON.stringify(pytestResults))
-    
-    const result = await processHookData('{"hook_event_name": "PreToolUse"}', { storage })
-    
-    expect(result.decision).toBeUndefined()
-  })
-
-  it('should handle pytest failing test results', async () => {
-    const storage = new MemoryStorage()
-    const pytestResults = {
-      testModules: [
-        {
-          moduleId: 'test_example.py',
-          tests: [
-            {
-              name: 'test_failing',
-              fullName: 'test_example.py::test_failing',
-              state: 'failed',
-              errors: [{ message: 'AssertionError: 1 != 2' }]
-            }
-          ]
-        }
-      ]
-    }
-    
-    await storage.saveTest(JSON.stringify(pytestResults))
-    
-    const result = await processHookData('{"hook_event_name": "PreToolUse"}', { storage })
-    
-    expect(result.decision).toBeUndefined()
-  })
-
-  it('should detect Python files from hook data', async () => {
-    const storage = new MemoryStorage()
-    const hookData = {
-      hook_event_name: 'PreToolUse',
-      tool_input: {
-        file_path: 'src/calculator.py'
-      }
-    }
-    
-    const result = await processHookData(JSON.stringify(hookData), { storage })
-    
-    expect(result.decision).toBeUndefined()
-  })
-})