xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,16 +0,0 @@
-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

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

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

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

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

@@ -1,336 +0,0 @@
-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

@@ -1,83 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,39 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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'
-}