xtrm-tools 2.0.0

package/project-skills/tdd-guard/src/contracts/types/Context.ts

@@ -0,0 +1,16 @@
+export interface ProcessedLintData {
+  hasIssues: boolean
+  summary: string
+  issuesByFile: Map<string, string[]>
+  totalIssues: number
+  errorCount: number
+  warningCount: number
+}
+
+export type Context = {
+  modifications: string
+  todo?: string
+  test?: string
+  lint?: ProcessedLintData
+  instructions?: string
+}

package/project-skills/tdd-guard/src/contracts/types/ModelClient.ts

@@ -0,0 +1,3 @@
+export interface IModelClient {
+  ask(prompt: string): Promise<string>
+}

package/project-skills/tdd-guard/src/contracts/types/ValidationResult.ts

@@ -0,0 +1,6 @@
+export type ValidationResult = {
+  decision: 'approve' | 'block' | undefined
+  reason: string
+  continue?: boolean
+  stopReason?: string
+}

package/project-skills/tdd-guard/src/guard/GuardManager.test.ts

@@ -0,0 +1,336 @@
+import { describe, it, expect, beforeEach } from 'vitest'
+import { GuardManager } from './GuardManager'
+import { Storage } from '../storage/Storage'
+import { MemoryStorage } from '../storage/MemoryStorage'
+import { FileStorage } from '../storage/FileStorage'
+
+describe('GuardManager', () => {
+  let storage: Storage
+  let guardManager: GuardManager
+
+  beforeEach(() => {
+    storage = new MemoryStorage()
+    guardManager = new GuardManager(storage)
+  })
+
+  describe('constructor', () => {
+    it('accepts a Storage instance', () => {
+      const customStorage = new MemoryStorage()
+      const manager = new GuardManager(customStorage)
+
+      expect(manager['storage']).toBe(customStorage)
+    })
+
+    it('uses FileStorage by default', () => {
+      const manager = new GuardManager()
+
+      expect(manager['storage']).toBeInstanceOf(FileStorage)
+    })
+  })
+
+  describe('isEnabled', () => {
+    it('returns true when no config exists (default enabled)', async () => {
+      expect(await guardManager.isEnabled()).toBe(true)
+    })
+
+    it('returns false when guard is disabled in config', async () => {
+      await storage.saveConfig(JSON.stringify({ guardEnabled: false }))
+
+      expect(await guardManager.isEnabled()).toBe(false)
+    })
+
+    it('returns true when guard is enabled in config', async () => {
+      await storage.saveConfig(JSON.stringify({ guardEnabled: true }))
+
+      expect(await guardManager.isEnabled()).toBe(true)
+    })
+  })
+
+  describe('enable', () => {
+    it('enables the guard when no config exists', async () => {
+      await guardManager.enable()
+
+      expect(await guardManager.isEnabled()).toBe(true)
+    })
+
+    it('enables the guard when previously disabled', async () => {
+      await guardManager.disable()
+      await guardManager.enable()
+
+      expect(await guardManager.isEnabled()).toBe(true)
+    })
+
+    it('preserves existing ignore patterns when enabling', async () => {
+      const customPatterns = ['*.custom', 'test/**']
+      await setupIgnorePatterns(storage, customPatterns)
+
+      await guardManager.enable()
+
+      expect(await guardManager.getIgnorePatterns()).toEqual(customPatterns)
+    })
+  })
+
+  describe('disable', () => {
+    it('disables the guard when no config exists', async () => {
+      await guardManager.disable()
+
+      expect(await guardManager.isEnabled()).toBe(false)
+    })
+
+    it('disables the guard when previously enabled', async () => {
+      await guardManager.enable()
+      await guardManager.disable()
+
+      expect(await guardManager.isEnabled()).toBe(false)
+    })
+
+    it('preserves existing ignore patterns when disabling', async () => {
+      const customPatterns = ['*.custom', 'test/**']
+      await setupIgnorePatterns(storage, customPatterns)
+
+      await guardManager.disable()
+
+      expect(await guardManager.getIgnorePatterns()).toEqual(customPatterns)
+    })
+  })
+
+  describe('getIgnorePatterns', () => {
+    it('returns default ignore patterns when no config exists', async () => {
+      const patterns = await guardManager.getIgnorePatterns()
+
+      expect(patterns).toEqual(GuardManager.DEFAULT_IGNORE_PATTERNS)
+    })
+
+    it('returns defaults when config exists but ignorePatterns is not provided', async () => {
+      await storage.saveConfig(
+        JSON.stringify({
+          guardEnabled: true,
+          // No ignorePatterns field
+        })
+      )
+
+      const patterns = await guardManager.getIgnorePatterns()
+
+      expect(patterns).toEqual(GuardManager.DEFAULT_IGNORE_PATTERNS)
+    })
+
+    it('returns custom patterns from config', async () => {
+      await setupIgnorePatterns(storage, [
+        '**/*.spec.ts',
+        'dist/**',
+        'build/**',
+      ])
+
+      const patterns = await guardManager.getIgnorePatterns()
+
+      expect(patterns).toContain('**/*.spec.ts')
+      expect(patterns).toContain('dist/**')
+      expect(patterns).toContain('build/**')
+    })
+
+    it('does not include default patterns when custom patterns are provided', async () => {
+      const customPatterns = ['*.custom', '**/*.unique', 'special/**']
+      await setupIgnorePatterns(storage, customPatterns)
+
+      const patterns = await guardManager.getIgnorePatterns()
+
+      GuardManager.DEFAULT_IGNORE_PATTERNS.forEach((defaultPattern) => {
+        expect(patterns).not.toContain(defaultPattern)
+      })
+    })
+  })
+
+  describe('shouldIgnoreFile', () => {
+    it('ignores files matching default patterns', async () => {
+      for (const pattern of GuardManager.DEFAULT_IGNORE_PATTERNS) {
+        // Convert pattern to file path (e.g., '*.md' -> 'file.md')
+        const filePath = pattern.replaceAll('*', 'file')
+        expect(await guardManager.shouldIgnoreFile(filePath)).toBe(true)
+      }
+    })
+
+    describe('suffix patterns with *.suffix.ext', () => {
+      it.each([
+        {
+          description: 'file with matching suffix in root',
+          path: 'bundle.min.js',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file with matching suffix in nested directory',
+          path: 'dist/assets/app.min.js',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file without the required suffix',
+          path: 'bundle.js',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['*.min.js'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+
+    describe('brace expansion', () => {
+      it.each([
+        {
+          description: 'file matching first option in braces',
+          path: 'config.yml',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file matching second option in braces',
+          path: 'config.yaml',
+          shouldIgnore: true,
+        },
+        {
+          description: 'nested file with brace-expanded extension',
+          path: 'src/components/App.tsx',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file not matching any brace option',
+          path: 'config.json',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['*.{yml,yaml}', '**/*.{ts,tsx}'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+
+    describe('directory/** patterns', () => {
+      it.each([
+        {
+          description: 'file directly in specified directory',
+          path: 'dist/bundle.js',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file deeply nested in specified directory',
+          path: 'dist/assets/images/logo.png',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file in directory with similar name',
+          path: 'distribute/file.js',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['dist/**'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+
+    describe('**/directory/** patterns', () => {
+      it.each([
+        {
+          description: 'directory at root level',
+          path: 'artifacts/output.txt',
+          shouldIgnore: true,
+        },
+        {
+          description: 'directory nested in another directory',
+          path: 'build/artifacts/output.txt',
+          shouldIgnore: true,
+        },
+        {
+          description: 'directory with partial name match',
+          path: 'my-artifacts/file.txt',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['**/artifacts/**'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+
+    describe('**/*.extension patterns', () => {
+      it.each([
+        {
+          description: 'file with matching extension in root',
+          path: 'app.test.ts',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file with matching extension in subdirectory',
+          path: 'src/app.test.ts',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file with matching extension deeply nested',
+          path: 'tests/unit/user.test.ts',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file without matching extension',
+          path: 'src/app.ts',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['**/*.test.ts'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+
+    describe('path/**/*.extension patterns', () => {
+      it.each([
+        {
+          description: 'file matching both path and extension',
+          path: 'src/tests/e2e.spec.js',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file with matching extension outside specified path',
+          path: 'lib/tests/e2e.spec.js',
+          shouldIgnore: false,
+        },
+        {
+          description: 'file in correct path but different extension',
+          path: 'src/tests/e2e.test.js',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['src/**/*.spec.js'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+
+    describe('hidden directories', () => {
+      it.each([
+        {
+          description: 'file directly in .venv',
+          path: '.venv/bin/python',
+          shouldIgnore: true,
+        },
+        {
+          description: 'deeply nested file in .venv',
+          path: '.venv/lib/python3.9/site-packages/module.py',
+          shouldIgnore: true,
+        },
+        {
+          description: 'file in visible directory',
+          path: 'venv/bin/python',
+          shouldIgnore: false,
+        },
+      ])('$description', async ({ path, shouldIgnore }) => {
+        await setupIgnorePatterns(storage, ['.venv/**'])
+        expect(await guardManager.shouldIgnoreFile(path)).toBe(shouldIgnore)
+      })
+    })
+  })
+})
+
+// Helper function to set up ignore patterns
+async function setupIgnorePatterns(
+  storage: Storage,
+  patterns: string[]
+): Promise<void> {
+  await storage.saveConfig(
+    JSON.stringify({
+      guardEnabled: true,
+      ignorePatterns: patterns,
+    })
+  )
+}

package/project-skills/tdd-guard/src/guard/GuardManager.ts

@@ -0,0 +1,83 @@
+import { Storage } from '../storage/Storage'
+import { FileStorage } from '../storage/FileStorage'
+import { minimatch } from 'minimatch'
+import {
+  GuardConfig,
+  GuardConfigSchema,
+} from '../contracts/schemas/guardSchemas'
+
+export class GuardManager {
+  private readonly storage: Storage
+  private readonly minimatchOptions = {
+    matchBase: true, // allows *.ext to match in any directory
+    nobrace: false, // enables brace expansion {a,b}
+    dot: true, // allows patterns to match files/dirs starting with .
+  } as const
+
+  static readonly DEFAULT_IGNORE_PATTERNS = [
+    '*.md',
+    '*.txt',
+    '*.log',
+    '*.json',
+    '*.yml',
+    '*.yaml',
+    '*.xml',
+    '*.html',
+    '*.css',
+    '*.rst',
+  ]
+
+  constructor(storage?: Storage) {
+    this.storage = storage ?? new FileStorage()
+  }
+
+  async isEnabled(): Promise<boolean> {
+    const config = await this.getConfig()
+    return config?.guardEnabled ?? true
+  }
+
+  async enable(): Promise<void> {
+    await this.setGuardEnabled(true)
+  }
+
+  async disable(): Promise<void> {
+    await this.setGuardEnabled(false)
+  }
+
+  async getIgnorePatterns(): Promise<string[]> {
+    const config = await this.getConfig()
+    return config?.ignorePatterns ?? GuardManager.DEFAULT_IGNORE_PATTERNS
+  }
+
+  async shouldIgnoreFile(filePath: string): Promise<boolean> {
+    const patterns = await this.getIgnorePatterns()
+
+    return patterns.some((pattern) =>
+      minimatch(filePath, pattern, this.minimatchOptions)
+    )
+  }
+
+  private async setGuardEnabled(enabled: boolean): Promise<void> {
+    const existingConfig = await this.getConfig()
+    const config: GuardConfig = {
+      ...existingConfig,
+      guardEnabled: enabled,
+    }
+    await this.storage.saveConfig(JSON.stringify(config))
+  }
+
+  private async getConfig(): Promise<GuardConfig | null> {
+    const configString = await this.storage.getConfig()
+    if (!configString) {
+      return null
+    }
+
+    try {
+      const parsed = JSON.parse(configString)
+      return GuardConfigSchema.parse(parsed)
+    } catch {
+      // Return null for invalid JSON or schema validation errors
+      return null
+    }
+  }
+}

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

@@ -0,0 +1,107 @@
+import { describe, test, expect, beforeEach } from 'vitest'
+import { HookEvents } from './HookEvents'
+import { MemoryStorage } from '../storage/MemoryStorage'
+import { testData } from '@testUtils'
+
+describe('HookEvents', () => {
+  let sut: Awaited<ReturnType<typeof setupHookEvents>>
+
+  beforeEach(async () => {
+    sut = await setupHookEvents()
+  })
+
+  describe('Write operation', () => {
+    const writeOp = testData.writeOperation()
+
+    beforeEach(async () => {
+      await sut.processEvent(writeOp)
+    })
+
+    test('stores expected data', async () => {
+      const data = await sut.readModifications()
+      expect(JSON.parse(data)).toStrictEqual(writeOp)
+    })
+  })
+
+  describe('Edit operation', () => {
+    const editOp = testData.editOperation()
+    beforeEach(async () => {
+      await sut.processEvent(editOp)
+    })
+
+    test('stores expected data', async () => {
+      const data = await sut.readModifications()
+      expect(JSON.parse(data)).toStrictEqual(editOp)
+    })
+  })
+
+  describe('MultiEdit operation', () => {
+    const multiEditOp = testData.multiEditOperation()
+    beforeEach(async () => {
+      await sut.processEvent(multiEditOp)
+    })
+
+    test('stores expected data', async () => {
+      const data = await sut.readModifications()
+      expect(JSON.parse(data)).toStrictEqual(multiEditOp)
+    })
+  })
+
+  describe('TodoWrite operation', () => {
+    const todoWriteOp = testData.todoWriteOperation()
+    beforeEach(async () => {
+      await sut.processEvent(todoWriteOp)
+    })
+
+    test('stores expected data', async () => {
+      const data = await sut.readTodos()
+      expect(JSON.parse(data)).toStrictEqual(todoWriteOp)
+    })
+  })
+
+  describe('overwrite behavior', () => {
+    test('overwrites previous content instead of appending', async () => {
+      // First write
+      await sut.processEvent(
+        testData.writeOperation({ tool_input: { file_path: '/path', content: 'first content' }})
+      )
+
+      // Second write should overwrite
+      await sut.processEvent(
+        testData.writeOperation({ tool_input: { file_path: '/path', content: 'second content' }})
+      )
+
+      const logContent = await sut.readModifications()
+      const parsed = JSON.parse(logContent)
+      expect(parsed.tool_input.content).toStrictEqual('second content')
+    })
+  })
+
+  // Test helper
+  async function setupHookEvents(): Promise<{
+    readModifications: () => Promise<string>
+    readTodos: () => Promise<string>
+    processEvent: (data: unknown) => Promise<void>
+  }> {
+    const storage = new MemoryStorage()
+    const hookEvents = new HookEvents(storage)
+
+    const readModifications = async (): Promise<string> => {
+      const modifications = await storage.getModifications()
+      if (modifications === null) throw new Error('No modifications content')
+      return modifications
+    }
+
+    const readTodos = async (): Promise<string> => {
+      const todo = await storage.getTodo()
+      if (todo === null) throw new Error('No todo content')
+      return todo
+    }
+
+    return {
+      readModifications,
+      readTodos,
+      processEvent: (data: unknown): Promise<void> => hookEvents.processEvent(data),
+    }
+  }
+})

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

@@ -0,0 +1,39 @@
+import {
+  HookData,
+  HookDataSchema,
+  isTodoWriteOperation,
+  ToolOperation,
+  ToolOperationSchema,
+} from '../contracts/schemas/toolSchemas'
+import { Storage } from '../storage/Storage'
+
+export type { HookData }
+
+export class HookEvents {
+  constructor(private readonly storage: Storage) {}
+
+  async processEvent(event: unknown): Promise<void> {
+    const hookResult = HookDataSchema.safeParse(event)
+    if (!hookResult.success) return
+
+    const operation = this.extractToolOperation(hookResult.data)
+    if (!operation) return
+
+    await this.persistOperation(operation)
+  }
+
+  private extractToolOperation(hook: HookData): ToolOperation | null {
+    const result = ToolOperationSchema.safeParse(hook)
+    return result.success ? result.data : null
+  }
+
+  private async persistOperation(operation: ToolOperation): Promise<void> {
+    const content = JSON.stringify(operation, null, 2)
+    
+    if (isTodoWriteOperation(operation)) {
+      await this.storage.saveTodo(content)
+    } else {
+      await this.storage.saveModifications(content)
+    }
+  }
+}

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

@@ -0,0 +1,16 @@
+export function detectFileType(hookData: unknown): 'python' | 'javascript' | 'php' {
+  // Handle different tool operation types
+  const toolInput = (hookData as { tool_input?: Record<string, unknown> }).tool_input
+  if (toolInput && typeof toolInput === 'object' && 'file_path' in toolInput) {
+    const filePath = toolInput.file_path
+    if (typeof filePath === 'string') {
+      if (filePath.endsWith('.py')) {
+        return 'python'
+      }
+      if (filePath.endsWith('.php')) {
+        return 'php'
+      }
+    }
+  }
+  return 'javascript'
+}