xtrm-tools 2.0.0

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

@@ -0,0 +1,327 @@
+import { describe, it, expect, vi } from 'vitest'
+import { handlePostToolLint, PostToolLintHandler, DEFAULT_RESULT } from './postToolLint'
+import { testData } from '@testUtils'
+import { Linter } from '../linters/Linter'
+import { MemoryStorage } from '../storage/MemoryStorage'
+import { LintData, LintResult } from '../contracts/schemas/lintSchemas'
+import { HookData } from '../contracts/schemas/toolSchemas'
+import { TestResult } from '../contracts/schemas/reporterSchemas'
+import { ValidationResult } from '../contracts/types/ValidationResult'
+
+describe('postToolLint', () => {
+  describe('PostToolLintHandler', () => {
+    it('uses null linter by default', () => {
+      const storage = new MemoryStorage()
+      const handler = new PostToolLintHandler(storage)
+      expect(handler['linter']).toBeNull()
+    })
+
+    it('accepts Linter instance in constructor', () => {
+      const storage = new MemoryStorage()
+      const testLinter = new TestLinter()
+      const handler = new PostToolLintHandler(storage, testLinter)
+      expect(handler['linter']).toBe(testLinter)
+    })
+
+    it('accepts null linter in constructor', () => {
+      const storage = new MemoryStorage()
+      const handler = new PostToolLintHandler(storage, null)
+      expect(handler['linter']).toBeNull()
+    })
+  })
+
+  it('should return default result for PreToolUse hooks', async () => {
+    const { result, parsedLint } = await runLintAndGetResult({
+      lintResult: testData.lintResultWithoutErrors(),
+      operation: { hook_event_name: 'PreToolUse' }
+    })
+
+    expect(result).toEqual(DEFAULT_RESULT)
+    expect(parsedLint).toBeNull()
+  })
+
+
+  describe('when processing tool operations', () => {
+    it('runs lint and saves results for Edit operations', async () => {
+      const { parsedLint } = await runLintAndGetResult()
+
+      expect(parsedLint).not.toBeNull()
+      expect(parsedLint!.files).toEqual([])
+      expect(parsedLint!.errorCount).toBe(0)
+      expect(parsedLint!.warningCount).toBe(0)
+    })
+
+    it('runs lint and saves results for Write operations', async () => {
+      const { parsedLint } = await runLintAndGetResult({
+        operation: { tool_name: 'Write' }
+      })
+
+      expect(parsedLint).not.toBeNull()
+      expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+    })
+
+    it('runs lint and saves results for MultiEdit operations', async () => {
+      const { parsedLint } = await runLintAndGetResult({
+        operation: { tool_name: 'MultiEdit' }
+      })
+
+      expect(parsedLint).not.toBeNull()
+      expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+    })
+
+    it('returns default result and does not save lint data when operation has no file paths', async () => {
+      const { result, parsedLint } = await runLintAndGetResult({
+        operation: {
+          tool_name: 'TodoWrite',
+          tool_input: { todos: [] }
+        }
+      })
+
+      expect(result).toEqual(DEFAULT_RESULT)
+      expect(parsedLint).toBeNull()
+    })
+
+    it('processes MultiEdit operations even when some edits lack file_path', async () => {
+      const { parsedLint } = await runLintAndGetResult({
+        operation: {
+          tool_name: 'MultiEdit',
+          tool_input: {
+            edits: [
+              { old_string: 'a', new_string: 'b' },  // missing file_path
+              { file_path: '/test/file.ts', old_string: 'c', new_string: 'd' }
+            ]
+          }
+        }
+      })
+
+      // Should still process the edit that has a file_path
+      expect(parsedLint).not.toBeNull()
+      expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+    })
+  })
+
+  it('should always save lint data to storage', async () => {
+    const lintData = testData.lintResultWithError()
+
+    const { parsedLint } = await runLintAndGetResult({ lintResult: lintData })
+
+    expect(parsedLint!.issues).toEqual(lintData.issues)
+    expect(parsedLint!.errorCount).toBe(1)
+  })
+
+  describe('when lint issues exist', () => {
+    describe('and notification flag is false', () => {
+      it('does not block the operation', async () => {
+        const { result } = await runLintAndGetResult({
+          lintResult: testData.lintResultWithError()
+        })
+
+        expect(result).toEqual(DEFAULT_RESULT)
+      })
+
+      it('saves hasNotifiedAboutLintIssues as false', async () => {
+        const { parsedLint } = await runLintAndGetResult({
+          lintResult: testData.lintResultWithError()
+        })
+
+        expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+      })
+    })
+
+    describe('and notification flag is true', () => {
+      it('blocks with detailed lint errors', async () => {
+        const { result } = await runLintAndGetResult({
+          lintResult: testData.lintResultWithError(),
+          initialLintData: testData.lintDataWithNotificationFlag()
+        })
+
+        expect(result.decision).toBe('block')
+        expect(result.reason).toContain('Lint issues detected:')
+      })
+
+      it('preserves the notification flag', async () => {
+        const { parsedLint } = await runLintAndGetResult({
+          lintResult: testData.lintResultWithError(),
+          initialLintData: testData.lintDataWithNotificationFlag()
+        })
+
+        expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(true)
+      })
+    })
+
+    describe('and tests are failing (red phase)', () => {
+      it('saves lint data without blocking', async () => {
+        const lintData = testData.lintResultWithError()
+        
+        const { parsedLint } = await runLintAndGetResult({
+          lintResult: lintData,
+          initialTestData: testData.failedTestResults()
+        })
+
+        expect(parsedLint!.issues).toEqual(lintData.issues)
+        expect(parsedLint!.errorCount).toBe(1)
+        expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+      })
+    })
+  })
+
+  describe('when storage errors occur', () => {
+    it('should treat storage read errors as no stored lint data', async () => {
+      // This test requires manual setup to spy on storage
+      const storage = new MemoryStorage()
+      const testLinter = new TestLinter(testData.lintResultWithoutErrors())
+      
+      // Make storage.getLint() throw an error only on the first call
+      const getLintSpy = vi.spyOn(storage, 'getLint')
+      getLintSpy.mockRejectedValueOnce(new Error('Storage error'))
+
+      const hookData = JSON.stringify({
+        ...testData.editOperation(),
+        hook_event_name: 'PostToolUse'
+      })
+      
+      const result = await handlePostToolLint(hookData, storage, testLinter)
+
+      // Should not block (treats error as no stored data)
+      expect(result).toEqual(DEFAULT_RESULT)
+
+      // Reset the spy and check that storage now contains the new lint data
+      getLintSpy.mockRestore()
+      const savedLint = await storage.getLint()
+      expect(savedLint).toBeTruthy()
+      const parsedLint = JSON.parse(savedLint!)
+      expect(parsedLint.hasNotifiedAboutLintIssues).toBe(false)
+      expect(parsedLint.issues).toEqual([])
+    })
+  })
+
+  describe('when linter is null', () => {
+    it('skips linting and returns default result', async () => {
+      const storage = new MemoryStorage()
+      const handler = new PostToolLintHandler(storage, null)
+      const hookData = {
+        ...testData.editOperation(),
+        hook_event_name: 'PostToolUse'
+      }
+
+      const result = await handler.handle(JSON.stringify(hookData))
+
+      expect(result).toEqual(DEFAULT_RESULT)
+      const savedLint = await storage.getLint()
+      expect(savedLint).toBeNull()
+    })
+  })
+
+  describe('when no lint issues exist', () => {
+    describe('and previous state had notification flag set', () => {
+      it('resets hasNotifiedAboutLintIssues to false', async () => {
+        const { parsedLint } = await runLintAndGetResult({
+          lintResult: testData.lintResultWithoutErrors(),
+          initialLintData: testData.lintDataWithNotificationFlag()
+        })
+
+        expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+      })
+
+      describe('and tests are passing', () => {
+        it('does not block', async () => {
+          const { result } = await runLintAndGetResult({
+            lintResult: testData.lintResultWithoutErrors(),
+            initialLintData: testData.lintDataWithNotificationFlag(),
+            initialTestData: testData.passingTestResults()
+          })
+
+          expect(result).toEqual(DEFAULT_RESULT)
+        })
+      })
+    })
+
+    describe('and previous state had issues and notification flag', () => {
+      it('resets hasNotifiedAboutLintIssues to false when issues are resolved', async () => {
+        const { parsedLint } = await runLintAndGetResult({
+          lintResult: testData.lintResultWithoutErrors(),
+          initialLintData: testData.lintData({
+            files: ['/src/example.ts'],
+            issues: [testData.lintIssue({ file: '/src/example.ts', line: 1, column: 1, message: "Error" })],
+            hasNotifiedAboutLintIssues: true
+          })
+        })
+
+        expect(parsedLint!.hasNotifiedAboutLintIssues).toBe(false)
+      })
+    })
+
+    it('saves clean lint data', async () => {
+      const { parsedLint } = await runLintAndGetResult({
+        lintResult: testData.lintResultWithoutErrors()
+      })
+
+      expect(parsedLint!.issues).toEqual([])
+      expect(parsedLint!.errorCount).toBe(0)
+      expect(parsedLint!.warningCount).toBe(0)
+    })
+  })
+})
+
+// Test helper functions
+interface LintTestOptions {
+  lintResult?: Omit<LintData, 'hasNotifiedAboutLintIssues'>
+  operation?: Partial<HookData>
+  storage?: MemoryStorage
+  initialLintData?: LintData
+  initialTestData?: TestResult
+}
+
+async function runLintAndGetResult(options: LintTestOptions = {}): Promise<{
+  result: ValidationResult,
+  parsedLint: LintData | null,
+  storage: MemoryStorage
+}> {
+  const { lintResult, operation = {}, storage: existingStorage, initialLintData, initialTestData } = options
+  const storage = existingStorage ?? new MemoryStorage()
+  
+  // Set up initial storage state if provided
+  if (initialLintData) {
+    await storage.saveLint(JSON.stringify(initialLintData))
+  }
+  if (initialTestData) {
+    await storage.saveTest(JSON.stringify(initialTestData))
+  }
+  
+  const testLinter = new TestLinter(lintResult ?? testData.lintResultWithoutErrors())
+  
+  let baseOperation
+  if (operation.tool_name === 'Write') {
+    baseOperation = testData.writeOperation()
+  } else if (operation.tool_name === 'MultiEdit') {
+    baseOperation = testData.multiEditOperation()
+  } else {
+    baseOperation = testData.editOperation()
+  }
+  
+  const hookData = JSON.stringify({
+    ...baseOperation,
+    hook_event_name: 'PostToolUse',
+    ...operation
+  })
+  
+  const result = await handlePostToolLint(hookData, storage, testLinter)
+  
+  const savedLint = await storage.getLint()
+  const parsedLint = savedLint ? JSON.parse(savedLint) : null
+  
+  return { result, parsedLint, storage }
+}
+
+// Test Linter implementation with configurable behavior
+class TestLinter implements Linter {
+  private readonly lintResult: LintResult
+  
+  constructor(lintResult?: LintResult) {
+    this.lintResult = lintResult ?? testData.lintResultWithoutErrors()
+  }
+  
+  async lint(): Promise<LintResult> {
+    return this.lintResult
+  }
+}

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

@@ -0,0 +1,165 @@
+import { ValidationResult } from '../contracts/types/ValidationResult'
+import { HookData, HookDataSchema } from '../contracts/schemas/toolSchemas'
+import { LintData, LintDataSchema, LintResult } from '../contracts/schemas/lintSchemas'
+import { Storage } from '../storage/Storage'
+import { Linter } from '../linters/Linter'
+
+export const DEFAULT_RESULT: ValidationResult = {
+  decision: undefined,
+  reason: ''
+}
+
+export class PostToolLintHandler {
+  private readonly linter: Linter | null
+  private readonly storage: Storage
+
+  constructor(storage: Storage, linter?: Linter | null) {
+    this.storage = storage
+    this.linter = linter ?? null
+  }
+
+  async handle(hookData: string): Promise<ValidationResult> {
+    // If no linter is configured, skip linting
+    if (!this.linter) {
+      return DEFAULT_RESULT
+    }
+    return handlePostToolLint(hookData, this.storage, this.linter)
+  }
+}
+
+function parseAndValidateHookData(hookData: string): HookData | null {
+  try {
+    const parsedData = JSON.parse(hookData)
+    const hookResult = HookDataSchema.safeParse(parsedData)
+    
+    if (!hookResult.success) {
+      return null
+    }
+    
+    // Only process PostToolUse hooks
+    if (hookResult.data.hook_event_name !== 'PostToolUse') {
+      return null
+    }
+    
+    return hookResult.data
+  } catch {
+    return null
+  }
+}
+
+async function getStoredLintData(storage: Storage): Promise<LintData | null> {
+  try {
+    const lintDataStr = await storage.getLint()
+    if (lintDataStr) {
+      return LintDataSchema.parse(JSON.parse(lintDataStr))
+    }
+  } catch {
+    // Treat any error as no stored data
+  }
+  return null
+}
+
+function createLintData(
+  lintResults: LintResult,
+  storedLintData: LintData | null
+): LintData {
+  const hasIssues = lintResults.errorCount > 0 || lintResults.warningCount > 0
+  
+  return {
+    ...lintResults,
+    hasNotifiedAboutLintIssues: hasIssues 
+      ? (storedLintData?.hasNotifiedAboutLintIssues ?? false)  // Preserve flag when issues exist
+      : false  // Reset flag when no issues
+  }
+}
+
+function createBlockResult(lintData: LintData): ValidationResult {
+  const formattedIssues = formatLintIssues(lintData.issues)
+  const summary = `\n✖ ${lintData.errorCount + lintData.warningCount} problems (${lintData.errorCount} errors, ${lintData.warningCount} warnings)`
+  
+  return {
+    decision: 'block',
+    reason: `Lint issues detected:${formattedIssues}\n${summary}\n\nPlease fix these issues before proceeding.`
+  }
+}
+
+function formatLintIssues(issues: LintData['issues']): string {
+  const issuesByFile = new Map<string, string[]>()
+  
+  for (const issue of issues) {
+    if (!issuesByFile.has(issue.file)) {
+      issuesByFile.set(issue.file, [])
+    }
+    const ruleInfo = issue.rule ? `  ${issue.rule}` : ''
+    issuesByFile.get(issue.file)!.push(
+      `  ${issue.line}:${issue.column}  ${issue.severity}  ${issue.message}${ruleInfo}`
+    )
+  }
+
+  let formattedIssues = ''
+  for (const [file, fileIssues] of issuesByFile) {
+    formattedIssues += `\n${file}\n${fileIssues.join('\n')}`
+  }
+  
+  return formattedIssues
+}
+
+export async function handlePostToolLint(
+  hookData: string,
+  storage: Storage,
+  linter: Linter
+): Promise<ValidationResult> {
+  const validatedHookData = parseAndValidateHookData(hookData)
+  if (!validatedHookData) {
+    return DEFAULT_RESULT
+  }
+
+  // Extract file paths from tool operation
+  const filePaths = extractFilePaths(validatedHookData)
+  if (filePaths.length === 0) {
+    return DEFAULT_RESULT
+  }
+
+  // Get current lint data to check hasNotifiedAboutLintIssues state
+  const storedLintData = await getStoredLintData(storage)
+
+  // Run linting on the files
+  const lintResults = await linter.lint(filePaths)
+  
+  // Create and save lint data
+  const lintData = createLintData(lintResults, storedLintData)
+  await storage.saveLint(JSON.stringify(lintData))
+  
+  const hasIssues = lintResults.errorCount > 0 || lintResults.warningCount > 0
+
+  // Block if:
+  // 1. PreToolUse has notified (flag is true)
+  // 2. There are still issues
+  if (storedLintData?.hasNotifiedAboutLintIssues && hasIssues) {
+    return createBlockResult(lintData)
+  }
+
+  return DEFAULT_RESULT
+}
+
+function extractFilePaths(hookData: HookData): string[] {
+  const toolInput = hookData.tool_input
+  if (!toolInput || typeof toolInput !== 'object') return []
+
+  const paths: string[] = []
+
+  if ('file_path' in toolInput && typeof toolInput.file_path === 'string') {
+    paths.push(toolInput.file_path)
+  }
+
+  // Handle multi-edit operations
+  if ('edits' in toolInput && Array.isArray(toolInput.edits)) {
+    for (const edit of toolInput.edits) {
+      if ('file_path' in edit && typeof edit.file_path === 'string') {
+        paths.push(edit.file_path)
+      }
+    }
+  }
+
+  return [...new Set(paths)] // Remove duplicates
+}