xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,465 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest'
-import { processHookData, defaultResult } from './processHookData'
-import { testData } from '@testUtils'
-import { UserPromptHandler } from './userPromptHandler'
-import { GuardManager } from '../guard/GuardManager'
-import { MemoryStorage } from '../storage/MemoryStorage'
-import { ValidationResult } from '../contracts/types/ValidationResult'
-import { Context } from '../contracts/types/Context'
-
-const BLOCK_RESULT = {
-  decision: 'block',
-  reason: 'TDD violation',
-} as const
-
-const WRITE_HOOK_DATA = testData.writeOperation()
-const EDIT_HOOK_DATA = testData.editOperation()
-const TODO_WRITE_HOOK_DATA = testData.todoWriteOperation()
-
-describe('processHookData', () => {
-  let sut: ReturnType<typeof createTestProcessor>
-
-  beforeEach(() => {
-    sut = createTestProcessor()
-  })
-
-  it('should return a ValidationResult', async () => {
-    const hookData = { type: 'test', data: 'some data' }
-
-    const result = await sut.process(hookData)
-
-    expect(result).toBeDefined()
-    expect(result).toHaveProperty('decision')
-    expect(result).toHaveProperty('reason')
-  })
-
-  it('should throw error on invalid JSON', async () => {
-    const invalidJson = '{ invalid json'
-
-    // For this test, we need to use processHookData directly since we're testing JSON parsing
-    await expect(processHookData(invalidJson)).rejects.toThrow()
-  })
-
-  it('should save modifications content to storage when tool is Edit', async () => {
-    await sut.process(EDIT_HOOK_DATA)
-
-    const savedModifications = await sut.getModifications()
-    const parsedModifications = JSON.parse(savedModifications!)
-    expect(parsedModifications).toEqual(EDIT_HOOK_DATA)
-  })
-
-  it('should save todo content to storage when tool is TodoWrite', async () => {
-    await sut.process(TODO_WRITE_HOOK_DATA)
-
-    const savedTodo = await sut.getTodo()
-    const parsedTodo = JSON.parse(savedTodo!)
-    expect(parsedTodo).toEqual(TODO_WRITE_HOOK_DATA)
-  })
-
-  it('should save modifications content when tool has content field', async () => {
-    await sut.process(WRITE_HOOK_DATA)
-
-    const savedModifications = await sut.getModifications()
-    const parsedModifications = JSON.parse(savedModifications!)
-    expect(parsedModifications).toEqual(WRITE_HOOK_DATA)
-  })
-
-  it('should call validator with context built from storage', async () => {
-    // Pre-populate storage
-    await sut.populateStorage({
-      modifications: 'existing modifications',
-      test: 'existing test',
-      todo: 'existing todo',
-    })
-
-    const result = await sut.process(EDIT_HOOK_DATA)
-
-    const actualContext = sut.getValidatorCallArgs()
-    
-    // Verify the context, parsing JSON to handle formatting differences
-    expect({
-      ...actualContext,
-      modifications: JSON.parse(actualContext!.modifications),
-    }).toEqual({
-      modifications: EDIT_HOOK_DATA,
-      test: 'existing test',
-      todo: 'existing todo',
-      lint: {
-        errorCount: 0,
-        warningCount: 0,
-        hasIssues: false,
-        totalIssues: 0,
-        issuesByFile: new Map(),
-        summary: 'No lint data available'
-      }
-    })
-    expect(result).toEqual(BLOCK_RESULT)
-  })
-
-  it('should not call validator for TodoWrite operations', async () => {
-    // Pre-populate storage with existing edits that might cause false blocks
-    await sut.populateStorage({
-      modifications: 'existing modifications that might trigger validation',
-    })
-
-    const result = await sut.process(TODO_WRITE_HOOK_DATA)
-
-    expect(sut.validatorHasBeenCalled()).toBe(false)
-    expect(result).toEqual(defaultResult)
-  })
-
-  it('should handle hook data with invalid schema gracefully', async () => {
-    // Invalid hook data that doesn't match either SimpleHookDataSchema or FullHookEventSchema
-    const invalidHookData = {
-      // This doesn't match FullHookEventSchema (missing required fields)
-      // and has invalid types for SimpleHookDataSchema
-      tool_name: 123, // Should be string
-      tool_input: "not an object", // Should be object
-    }
-
-    const result = await sut.process(invalidHookData)
-
-    // Should return default result without calling validator
-    expect(sut.validatorHasBeenCalled()).toBe(false)
-    expect(result).toEqual(defaultResult)
-  })
-
-  describe('PostToolUse hook handling', () => {
-    it('should delegate to handlePostToolLint for PostToolUse events', async () => {
-      const postToolUseHook = {
-        ...EDIT_HOOK_DATA,
-        hook_event_name: 'PostToolUse',
-        tool_output: { success: true }
-      }
-
-      const result = await sut.process(postToolUseHook)
-
-      // Should not call the validator
-      expect(sut.validatorHasBeenCalled()).toBe(false)
-      // Result depends on lint state, but should return a valid result
-      expect(result).toHaveProperty('decision')
-      expect(result).toHaveProperty('reason')
-    })
-  })
-
-  describe('Ignore patterns filtering', () => {
-    it('skips validation when using default ignore patterns', async () => {
-      for (const pattern of GuardManager.DEFAULT_IGNORE_PATTERNS) {
-        // Convert pattern to file path (e.g., '*.md' -> '/path/to/file.md')
-        const filePath = pattern.replaceAll('*', '/path/to/file')
-        
-        const nonCodeFileData = {
-          ...EDIT_HOOK_DATA,
-          tool_input: {
-            file_path: filePath,
-            old_string: 'old content',
-            new_string: 'new content'
-          }
-        }
-
-        const result = await sut.process(nonCodeFileData)
-        
-        expect(sut.validatorHasBeenCalled()).toBe(false)
-        expect(result).toEqual(defaultResult)
-      }
-    })
-
-    it.each([
-      {
-        description: 'files matching custom extensions',
-        filePath: 'file.custom',
-      },
-      {
-        description: 'files in ignored directories',
-        filePath: 'build/output.js',
-      },
-      {
-        description: 'files matching glob patterns',
-        filePath: 'src/api/schema.generated.ts',
-      },
-    ])('skips validation when using custom ignore patterns for $description', async ({ filePath }) => {
-      // Set up custom ignore patterns
-      const customPatterns = ['*.custom', 'build/**', '**/*.generated.ts']
-      await sut.storage.saveConfig(JSON.stringify({
-        guardEnabled: true,
-        ignorePatterns: customPatterns
-      }))
-
-      const fileData = {
-        ...EDIT_HOOK_DATA,
-        tool_input: {
-          file_path: filePath,
-          old_string: 'old content',
-          new_string: 'new content'
-        }
-      }
-
-      const result = await sut.process(fileData)
-      
-      expect(sut.validatorHasBeenCalled()).toBe(false)
-      expect(result).toEqual(defaultResult)
-    })
-  })
-
-  describe('PreToolUse lint notification', () => {
-    it('should block when tests pass, lint issues exist, and not yet notified', async () => {
-      // Setup: passing tests
-      await sut.populateStorage({
-        test: JSON.stringify(testData.passingTestResults())
-      })
-      
-      // Setup: lint issues with notification flag false
-      await sut.storage.saveLint(JSON.stringify(
-        testData.lintDataWithError({
-          hasNotifiedAboutLintIssues: false
-        })
-      ))
-
-      const result = await sut.process(EDIT_HOOK_DATA)
-
-      expect(result.decision).toBe('block')
-      expect(result.reason).toContain('Code quality issues detected')
-      // Should not call the main validator
-      expect(sut.validatorHasBeenCalled()).toBe(false)
-    })
-
-    it('should not block when tests are failing (red phase)', async () => {
-      // Setup: failing tests
-      await sut.populateStorage({
-        test: JSON.stringify(testData.failedTestResults())
-      })
-      
-      // Setup: lint issues with notification flag false
-      await sut.storage.saveLint(JSON.stringify(
-        testData.lintDataWithError({
-          hasNotifiedAboutLintIssues: false
-        })
-      ))
-
-      const result = await sut.process(EDIT_HOOK_DATA)
-
-      // Should proceed to normal validation
-      expect(result).toEqual(BLOCK_RESULT)
-      expect(sut.validatorHasBeenCalled()).toBe(true)
-    })
-
-    it('should not block when no lint issues exist', async () => {
-      // Setup: passing tests
-      await sut.populateStorage({
-        test: JSON.stringify(testData.passingTestResults())
-      })
-      
-      // Setup: no lint issues
-      await sut.storage.saveLint(JSON.stringify(
-        testData.lintDataWithoutErrors({
-          hasNotifiedAboutLintIssues: false
-        })
-      ))
-
-      const result = await sut.process(EDIT_HOOK_DATA)
-
-      // Should proceed to normal validation
-      expect(result).toEqual(BLOCK_RESULT)
-      expect(sut.validatorHasBeenCalled()).toBe(true)
-    })
-
-    it('should not block when already notified', async () => {
-      // Setup: passing tests
-      await sut.populateStorage({
-        test: JSON.stringify(testData.passingTestResults())
-      })
-      
-      // Setup: lint issues with notification flag true
-      await sut.storage.saveLint(JSON.stringify(
-        testData.lintDataWithError({
-          hasNotifiedAboutLintIssues: true
-        })
-      ))
-
-      const result = await sut.process(EDIT_HOOK_DATA)
-
-      // Should proceed to normal validation
-      expect(result).toEqual(BLOCK_RESULT)
-      expect(sut.validatorHasBeenCalled()).toBe(true)
-    })
-
-    it('should set notification flag after blocking', async () => {
-      // Setup: passing tests
-      await sut.populateStorage({
-        test: JSON.stringify(testData.passingTestResults())
-      })
-      
-      // Setup: lint issues with notification flag false
-      await sut.storage.saveLint(JSON.stringify(
-        testData.lintDataWithError({
-          hasNotifiedAboutLintIssues: false
-        })
-      ))
-
-      await sut.process(EDIT_HOOK_DATA)
-
-      // Check that the flag was updated
-      const savedLint = await sut.storage.getLint()
-      const parsedLint = JSON.parse(savedLint!)
-      expect(parsedLint.hasNotifiedAboutLintIssues).toBe(true)
-    })
-  })
-
-  describe('SessionStart handling', () => {
-    let result: ValidationResult
-
-    beforeEach(async () => {
-      // Populate storage with data
-      await sut.populateStorage({
-        test: JSON.stringify(testData.passingTestResults()),
-        todo: JSON.stringify(testData.todoWriteOperation()),
-        modifications: JSON.stringify(testData.editOperation()),
-        lint: JSON.stringify(testData.lintDataWithoutErrors()),
-        config: JSON.stringify({ guardEnabled: true })
-      })
-
-      const sessionStartData = testData.sessionStart()
-      result = await sut.process(sessionStartData)
-    })
-
-    it('should clear transient data when SessionStart event is received', async () => {
-      // Verify transient data is cleared
-      expect(await sut.getTest()).toBeNull()
-      expect(await sut.getTodo()).toBeNull()
-      expect(await sut.getModifications()).toBeNull()
-      expect(await sut.getLint()).toBeNull()
-    })
-
-    it('should preserve config data when SessionStart event is received', async () => {
-      expect(await sut.getConfig()).toBe(JSON.stringify({ guardEnabled: true }))
-    })
-
-    it('should return defaultResult when SessionStart event is processed', () => {
-      expect(result).toEqual(defaultResult)
-    })
-  })
-
-  describe('UserPromptHandler integration', () => {
-    it('should enable TDD Guard when user sends "tdd-guard on"', async () => {
-      const storage = new MemoryStorage()
-      const guardManager = new GuardManager(storage)
-      await guardManager.disable() // Ensure it starts disabled
-      const userPromptHandler = new UserPromptHandler(guardManager)
-      const userPromptData = testData.userPromptSubmit({ prompt: 'tdd-guard on' })
-      
-      await processHookData(JSON.stringify(userPromptData), { 
-        userPromptHandler 
-      })
-
-      expect(await guardManager.isEnabled()).toBe(true)
-    })
-
-    it('should disable TDD Guard when user sends "tdd-guard off"', async () => {
-      const storage = new MemoryStorage()
-      const guardManager = new GuardManager(storage)
-      await guardManager.enable() // Ensure it starts enabled
-      const userPromptHandler = new UserPromptHandler(guardManager)
-      const userPromptData = testData.userPromptSubmit({ prompt: 'tdd-guard off' })
-      
-      await processHookData(JSON.stringify(userPromptData), { 
-        userPromptHandler 
-      })
-
-      expect(await guardManager.isEnabled()).toBe(false)
-    })
-
-    it('should not proceed with validation when TDD Guard is disabled', async () => {
-      const storage = new MemoryStorage()
-      const guardManager = new GuardManager(storage)
-      await guardManager.disable() // Ensure guard is disabled
-      const userPromptHandler = new UserPromptHandler(guardManager)
-      const mockValidator = vi.fn()
-      
-      // Try to process an edit operation
-      const editData = testData.editOperation()
-      
-      const result = await processHookData(JSON.stringify(editData), { 
-        storage,
-        userPromptHandler,
-        validator: mockValidator
-      })
-
-      expect(mockValidator).not.toHaveBeenCalled()
-      expect(result).toEqual(defaultResult)
-    })
-
-    it('should proceed with validation when TDD Guard is enabled', async () => {
-      const storage = new MemoryStorage()
-      const guardManager = new GuardManager(storage)
-      await guardManager.enable() // Ensure guard is enabled
-      const userPromptHandler = new UserPromptHandler(guardManager)
-      const mockValidator = vi.fn().mockResolvedValue(BLOCK_RESULT)
-      
-      // Try to process an edit operation
-      const editData = testData.editOperation()
-      
-      const result = await processHookData(JSON.stringify(editData), { 
-        storage,
-        userPromptHandler,
-        validator: mockValidator
-      })
-
-      expect(mockValidator).toHaveBeenCalled()
-      expect(result).toEqual(BLOCK_RESULT)
-    })
-  })
-})
-
-// Test setup helper
-function createTestProcessor() {
-  const storage = new MemoryStorage()
-  const mockValidator = vi.fn().mockResolvedValue(BLOCK_RESULT)
-  
-  // Create a GuardManager and UserPromptHandler that defaults to enabled for tests
-  const guardManager = new GuardManager(storage)
-  const userPromptHandler = new UserPromptHandler(guardManager)
-  
-  // Helper to process hook data
-  const process = async (hookData: unknown): Promise<ValidationResult> => {
-    // Ensure TDD Guard is enabled for tests unless explicitly disabled
-    await guardManager.enable()
-    
-    return processHookData(JSON.stringify(hookData), {
-      storage, 
-      validator: mockValidator,
-      userPromptHandler
-    })
-  }
-  
-  // Pre-populate storage helper
-  const populateStorage = async (data: { 
-    modifications?: string; 
-    test?: string; 
-    todo?: string;
-    lint?: string;
-    config?: string;
-  }): Promise<void> => {
-    if (data.modifications) await storage.saveModifications(data.modifications)
-    if (data.test) await storage.saveTest(data.test)
-    if (data.todo) await storage.saveTodo(data.todo)
-    if (data.lint) await storage.saveLint(data.lint)
-    if (data.config) await storage.saveConfig(data.config)
-  }
-  
-  return {
-    storage,
-    process,
-    populateStorage,
-    
-    // Storage accessors
-    getModifications: (): Promise<string | null> => storage.getModifications(),
-    getTest: (): Promise<string | null> => storage.getTest(),
-    getTodo: (): Promise<string | null> => storage.getTodo(),
-    getLint: (): Promise<string | null> => storage.getLint(),
-    getConfig: (): Promise<string | null> => storage.getConfig(),
-    
-    // Validator checks
-    validatorHasBeenCalled: (): boolean => mockValidator.mock.calls.length > 0,
-    getValidatorCallArgs: (): Context | null => mockValidator.mock.calls[0]?.[0] ?? null,
-  }
-}

package/project-skills/tdd-guard/src/hooks/processHookData.ts

@@ -1,203 +0,0 @@
-import { buildContext } from '../cli/buildContext'
-import { HookData, HookEvents } from './HookEvents'
-import { PostToolLintHandler } from './postToolLint'
-import { detectFileType } from './fileTypeDetection'
-import { LinterProvider } from '../providers/LinterProvider'
-import { UserPromptHandler } from './userPromptHandler'
-import { SessionHandler } from './sessionHandler'
-import { GuardManager } from '../guard/GuardManager'
-import { Storage } from '../storage/Storage'
-import { FileStorage } from '../storage/FileStorage'
-import { ValidationResult } from '../contracts/types/ValidationResult'
-import { Context } from '../contracts/types/Context'
-import { HookDataSchema, isTodoWriteOperation, ToolOperationSchema } from '../contracts/schemas/toolSchemas'
-import { PytestResultSchema } from '../contracts/schemas/pytestSchemas'
-import { isTestPassing, TestResultSchema } from '../contracts/schemas/reporterSchemas'
-import { LintDataSchema } from '../contracts/schemas/lintSchemas'
-
-export interface ProcessHookDataDeps {
-  storage?: Storage
-  validator?: (context: Context) => Promise<ValidationResult>
-  userPromptHandler?: UserPromptHandler
-}
-
-export const defaultResult: ValidationResult = {
-  decision: undefined,
-  reason: '',
-}
-
-function extractFilePath(parsedData: unknown): string | null {
-  if (!parsedData || typeof parsedData !== 'object') {
-    return null
-  }
-  
-  const data = parsedData as Record<string, unknown>
-  const toolInput = data.tool_input
-  
-  if (!toolInput || typeof toolInput !== 'object' || !('file_path' in toolInput)) {
-    return null
-  }
-  
-  const filePath = (toolInput as Record<string, unknown>).file_path
-  if (typeof filePath !== 'string') {
-    return null
-  }
-  
-  return filePath
-}
-
-export async function processHookData(
-  inputData: string,
-  deps: ProcessHookDataDeps = {}
-): Promise<ValidationResult> {
-  const parsedData = JSON.parse(inputData)
-  
-  // Initialize dependencies
-  const storage = deps.storage ?? new FileStorage()
-  const guardManager = new GuardManager(storage)
-  const userPromptHandler = deps.userPromptHandler ?? new UserPromptHandler(guardManager)
-  
-  // Skip validation for ignored files based on patterns
-  const filePath = extractFilePath(parsedData)
-  if (filePath && await guardManager.shouldIgnoreFile(filePath)) {
-    return defaultResult
-  }
-  const sessionHandler = new SessionHandler(storage)
-  
-  // Process SessionStart events
-  if (parsedData.hook_event_name === 'SessionStart') {
-    await sessionHandler.processSessionStart(inputData)
-    return defaultResult
-  }
-  
-  // Process user commands
-  const stateResult = await userPromptHandler.processUserCommand(inputData)
-  if (stateResult) {
-    return stateResult
-  }
-
-  // Check if guard is disabled and return early if so
-  const disabledResult = await userPromptHandler.getDisabledResult()
-  if (disabledResult) {
-    return disabledResult
-  }
-
-  // Create lintHandler with linter from provider
-  const linterProvider = new LinterProvider()
-  const linter = linterProvider.getLinter()
-  const lintHandler = new PostToolLintHandler(storage, linter)
-
-
-  const hookResult = HookDataSchema.safeParse(parsedData)
-  if (!hookResult.success) {
-    return defaultResult
-  }
-
-  await processHookEvent(parsedData, storage)
-
-  // Check if this is a PostToolUse event
-  if (hookResult.data.hook_event_name === 'PostToolUse') {
-    return await lintHandler.handle(inputData)
-  }
-
-  if (shouldSkipValidation(hookResult.data)) {
-    return defaultResult
-  }
-
-  // For PreToolUse, check if we should notify about lint issues
-  if (hookResult.data.hook_event_name === 'PreToolUse') {
-    const lintNotification = await checkLintNotification(storage, hookResult.data)
-    if (lintNotification.decision === 'block') {
-      return lintNotification
-    }
-  }
-
-  return await performValidation(deps)
-}
-
-async function processHookEvent(parsedData: unknown, storage?: Storage): Promise<void> {
-  if (storage) {
-    const hookEvents = new HookEvents(storage)
-    await hookEvents.processEvent(parsedData)
-  }
-}
-
-function shouldSkipValidation(hookData: HookData): boolean {
-  const operationResult = ToolOperationSchema.safeParse({
-    ...hookData,
-    tool_input: hookData.tool_input,
-  })
-
-  return !operationResult.success || isTodoWriteOperation(operationResult.data)
-}
-
-async function performValidation(deps: ProcessHookDataDeps): Promise<ValidationResult> {
-  if (deps.validator && deps.storage) {
-    const context = await buildContext(deps.storage)
-    return await deps.validator(context)
-  }
-  
-  return defaultResult
-}
-
-async function checkLintNotification(storage: Storage, hookData: HookData): Promise<ValidationResult> {
-  // Get test results to check if tests are passing
-  let testsPassing = false
-  try {
-    const testStr = await storage.getTest()
-    if (testStr) {
-      const fileType = detectFileType(hookData)
-      const testResult = fileType === 'python' 
-        ? PytestResultSchema.safeParse(JSON.parse(testStr))
-        : TestResultSchema.safeParse(JSON.parse(testStr))
-      if (testResult.success) {
-        testsPassing = isTestPassing(testResult.data)
-      }
-    }
-  } catch {
-    testsPassing = false
-  }
-
-  // Only proceed if tests are passing
-  if (!testsPassing) {
-    return defaultResult
-  }
-
-  // Get lint data
-  let lintData
-  try {
-    const lintStr = await storage.getLint()
-    if (lintStr) {
-      lintData = LintDataSchema.parse(JSON.parse(lintStr))
-    }
-  } catch {
-    return defaultResult
-  }
-
-  // Only proceed if lint data exists
-  if (!lintData) {
-    return defaultResult
-  }
-
-  const hasIssues = lintData.errorCount > 0 || lintData.warningCount > 0
-
-  // Block if:
-  // 1. Tests are passing (already checked)
-  // 2. There are lint issues
-  // 3. hasNotifiedAboutLintIssues is false (not yet notified)
-  if (hasIssues && !lintData.hasNotifiedAboutLintIssues) {
-    // Update the notification flag and save
-    const updatedLintData = {
-      ...lintData,
-      hasNotifiedAboutLintIssues: true
-    }
-    await storage.saveLint(JSON.stringify(updatedLintData))
-
-    return {
-      decision: 'block',
-      reason: 'Code quality issues detected. You need to fix those first before making any other changes. Remember to exercise system thinking and design awareness to ensure continuous architectural improvements. Consider: design patterns, SOLID principles, DRY, types and interfaces, and architectural improvements. Apply equally to implementation and test code. Use test data factories, helpers, and beforeEach to better organize tests.'
-    }
-  }
-
-  return defaultResult
-}