xtrm-tools 2.2.0 → 2.4.0

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

@@ -1,136 +0,0 @@
-import { describe, test, expect, beforeEach } from 'vitest'
-import { SessionHandler } from './sessionHandler'
-import { MemoryStorage } from '../storage/MemoryStorage'
-import { FileStorage } from '../storage/FileStorage'
-import { testData } from '@testUtils'
-import type { SessionStart } from '../contracts/schemas/toolSchemas'
-
-describe('SessionHandler', () => {
-  let storage: MemoryStorage
-  let handler: SessionHandler
-
-  beforeEach(() => {
-    storage = new MemoryStorage()
-    handler = new SessionHandler(storage)
-  })
-
-  describe('constructor', () => {
-    test('accepts a Storage instance', () => {
-      expect(handler['storage']).toBe(storage)
-    })
-
-    test('creates a default FileStorage if none provided', () => {
-      const customHandler = new SessionHandler()
-
-      expect(customHandler['storage']).toBeInstanceOf(FileStorage)
-    })
-  })
-
-  describe('processSessionStart', () => {
-    describe('transient data clearing', () => {
-      beforeEach(async () => {
-        await populateAllStorageTypes()
-      })
-
-      describe('when SessionStart event is received', () => {
-      beforeEach(async () => {
-        const sessionStartData = testData.sessionStart()
-        await handler.processSessionStart(JSON.stringify(sessionStartData))
-      })
-
-      test('clears test data', async () => {
-        expect(await storage.getTest()).toBeNull()
-      })
-
-      test('clears todo data', async () => {
-        expect(await storage.getTodo()).toBeNull()
-      })
-
-      test('clears modifications data', async () => {
-        expect(await storage.getModifications()).toBeNull()
-      })
-
-      test('clears lint data', async () => {
-        expect(await storage.getLint()).toBeNull()
-      })
-
-      test('preserves config data', async () => {
-        expect(await storage.getConfig()).toBe('config data')
-      })
-    })
-
-    describe('when non-SessionStart event is received', () => {
-      beforeEach(async () => {
-        const nonSessionStartData = testData.editOperation()
-        await handler.processSessionStart(JSON.stringify(nonSessionStartData))
-      })
-
-      test('preserves test data', async () => {
-        expect(await storage.getTest()).toBe('test data')
-      })
-
-      test('preserves todo data', async () => {
-        expect(await storage.getTodo()).toBe('todo data')
-      })
-
-      test('preserves modifications data', async () => {
-        expect(await storage.getModifications()).toBe('modifications data')
-      })
-
-      test('preserves lint data', async () => {
-        expect(await storage.getLint()).toBe('lint data')
-      })
-
-      test('preserves config data', async () => {
-        expect(await storage.getConfig()).toBe('config data')
-      })
-    })
-    })
-
-    describe('custom instructions', () => {
-      describe('when no instructions exist', () => {
-        test.each(['startup', 'resume', 'clear'] as const)(
-          'creates default instructions on %s event',
-          async (source) => {
-            const instructions = await startAndGetInstructions(source)
-
-            expect(instructions).toContain('## TDD Fundamentals')
-          }
-        )
-      })
-
-      describe('when instructions already exist', () => {
-        const customInstructions = '## My Custom TDD Rules'
-        
-        beforeEach(async () => {
-          await storage.saveInstructions(customInstructions)
-        })
-
-        test.each(['startup', 'resume', 'clear'] as const)(
-          'preserves existing instructions on %s event',
-          async (source) => {
-            const instructions = await startAndGetInstructions(source)
-            
-            expect(instructions).toBe(customInstructions)
-            expect(instructions).not.toContain('## Rules')
-          }
-        )
-      })
-    })
-  })
-
-  // Test helpers
-  async function populateAllStorageTypes() {
-    await storage.saveTest('test data')
-    await storage.saveTodo('todo data')
-    await storage.saveModifications('modifications data')
-    await storage.saveLint('lint data')
-    await storage.saveConfig('config data')
-  }
-
-  async function startAndGetInstructions(source: SessionStart['source']): Promise<string | null> {
-    const sessionData = testData.sessionStart({ source })
-    await handler.processSessionStart(JSON.stringify(sessionData))
-    return storage.getInstructions()
-  }
-})

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

@@ -1,31 +0,0 @@
-import { Storage } from '../storage/Storage'
-import { FileStorage } from '../storage/FileStorage'
-import { SessionStartSchema } from '../contracts/schemas/toolSchemas'
-import { RULES } from '../validation/prompts/rules'
-
-export class SessionHandler {
-  private readonly storage: Storage
-
-  constructor(storage?: Storage) {
-    this.storage = storage ?? new FileStorage()
-  }
-
-  async processSessionStart(hookData: string): Promise<void> {
-    const parsedData = JSON.parse(hookData)
-    const sessionStartResult = SessionStartSchema.safeParse(parsedData)
-    
-    if (!sessionStartResult.success) {
-      return
-    }
-
-    await this.ensureInstructionsExist()
-    await this.storage.clearTransientData()
-  }
-
-  private async ensureInstructionsExist(): Promise<void> {
-    const existingInstructions = await this.storage.getInstructions()
-    if (!existingInstructions) {
-      await this.storage.saveInstructions(RULES)
-    }
-  }
-}

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

@@ -1,131 +0,0 @@
-import { describe, test, expect, beforeEach } from 'vitest'
-import { UserPromptHandler } from './userPromptHandler'
-import { GuardManager } from '../guard/GuardManager'
-import { MemoryStorage } from '../storage/MemoryStorage'
-import { testData } from '@testUtils'
-
-describe('UserPromptHandler', () => {
-  let storage: MemoryStorage
-  let guardManager: GuardManager
-  let handler: UserPromptHandler
-
-  beforeEach(() => {
-    storage = new MemoryStorage()
-    guardManager = new GuardManager(storage)
-    handler = new UserPromptHandler(guardManager)
-  })
-
-  describe('constructor', () => {
-    test('accepts a GuardManager instance', () => {
-      expect(handler['guardManager']).toBe(guardManager)
-    })
-
-    test('creates a default GuardManager if none provided', () => {
-      const customHandler = new UserPromptHandler()
-
-      expect(customHandler['guardManager']).toBeInstanceOf(GuardManager)
-    })
-  })
-
-  describe('processUserCommand', () => {
-    test('only processes UserPromptSubmit events', async () => {
-      await guardManager.disable() // Ensure guard starts disabled
-      const hookData = {
-        ...testData.userPromptSubmit({ prompt: 'tdd-guard on' }),
-        hook_event_name: 'PreToolUse' // Not UserPromptSubmit
-      }
-
-      await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(await guardManager.isEnabled()).toBe(false) // Should not enable
-    })
-
-    test('enables guard when prompt is "tdd-guard on"', async () => {
-      await guardManager.disable() // Ensure guard starts disabled
-      const hookData = testData.userPromptSubmit({ prompt: 'tdd-guard on' })
-
-      await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(await guardManager.isEnabled()).toBe(true)
-    })
-
-    test('disables guard when prompt is "tdd-guard off"', async () => {
-      await guardManager.enable() // Ensure guard starts enabled
-      const hookData = testData.userPromptSubmit({ prompt: 'tdd-guard off' })
-
-      await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(await guardManager.isEnabled()).toBe(false)
-    })
-
-    test('enables guard when prompt is "TDD-Guard ON" (mixed case)', async () => {
-      await guardManager.disable() // Ensure guard starts disabled
-      const hookData = testData.userPromptSubmit({ prompt: 'TDD-Guard ON' })
-
-      await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(await guardManager.isEnabled()).toBe(true)
-    })
-
-    test('disables guard when prompt is "Tdd-Guard Off" (mixed case)', async () => {
-      await guardManager.enable() // Ensure guard starts enabled
-      const hookData = testData.userPromptSubmit({ prompt: 'Tdd-Guard Off' })
-
-      await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(await guardManager.isEnabled()).toBe(false)
-    })
-
-    test('stops operation and prevents "tdd-guard on" command from reaching agent', async () => {
-      const hookData = testData.userPromptSubmit({ prompt: 'tdd-guard on' })
-
-      const result = await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(result).toEqual({
-        decision: undefined,
-        reason: 'TDD Guard enabled',
-        continue: false,
-        stopReason: 'TDD Guard enabled'
-      })
-    })
-
-    test('stops operation and prevents "tdd-guard off" command from reaching agent', async () => {
-      const hookData = testData.userPromptSubmit({ prompt: 'tdd-guard off' })
-
-      const result = await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(result).toEqual({
-        decision: undefined,
-        reason: 'TDD Guard disabled',
-        continue: false,
-        stopReason: 'TDD Guard disabled'
-      })
-    })
-
-    test('returns undefined for non-guard commands', async () => {
-      const hookData = testData.userPromptSubmit({ prompt: 'run tests please' })
-
-      const result = await handler.processUserCommand(JSON.stringify(hookData))
-
-      expect(result).toBeUndefined()
-    })
-  })
-
-  describe('getDisabledResult', () => {
-    test('returns defaultResult when guard is disabled', async () => {
-      await guardManager.disable()
-
-      const result = await handler.getDisabledResult()
-
-      expect(result).toEqual({ decision: undefined, reason: '' })
-    })
-
-    test('returns undefined when guard is enabled', async () => {
-      await guardManager.enable()
-
-      const result = await handler.getDisabledResult()
-
-      expect(result).toBeUndefined()
-    })
-  })
-})

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

@@ -1,55 +0,0 @@
-import { GuardManager } from '../guard/GuardManager'
-import { ValidationResult } from '../contracts/types/ValidationResult'
-
-export class UserPromptHandler {
-  private readonly guardManager: GuardManager
-  private readonly GUARD_COMMANDS = {
-    ON: 'tdd-guard on',
-    OFF: 'tdd-guard off'
-  } as const
-
-  constructor(guardManager?: GuardManager) {
-    this.guardManager = guardManager ?? new GuardManager()
-  }
-
-  async processUserCommand(hookData: string): Promise<ValidationResult | undefined> {
-    const data = JSON.parse(hookData)
-    
-    // Only process UserPromptSubmit events
-    if (data.hook_event_name !== 'UserPromptSubmit') {
-      return undefined
-    }
-    
-    const command = data.prompt?.toLowerCase()
-    
-    switch (command) {
-      case this.GUARD_COMMANDS.ON:
-        await this.guardManager.enable()
-        return this.createBlockResult('TDD Guard enabled')
-      
-      case this.GUARD_COMMANDS.OFF:
-        await this.guardManager.disable()
-        return this.createBlockResult('TDD Guard disabled')
-      
-      default:
-        return undefined
-    }
-  }
-
-  private createBlockResult(message: string): ValidationResult {
-    return {
-      decision: undefined,
-      reason: message,
-      continue: false,
-      stopReason: message
-    }
-  }
-
-  async getDisabledResult(): Promise<ValidationResult | undefined> {
-    const isEnabled = await this.guardManager.isEnabled()
-    if (!isEnabled) {
-      return { decision: undefined, reason: '' }
-    }
-    return undefined
-  }
-}

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

@@ -1,19 +0,0 @@
-// Storage exports
-export { Storage } from './storage/Storage'
-export { FileStorage } from './storage/FileStorage'
-export { MemoryStorage } from './storage/MemoryStorage'
-
-// Config exports
-export { Config, DEFAULT_DATA_DIR } from './config/Config'
-export type { ConfigOptions } from './contracts/types/ConfigOptions'
-
-// Contract exports - Types
-export type { Context } from './contracts/types/Context'
-export type { IModelClient } from './contracts/types/ModelClient'
-export type { ValidationResult } from './contracts/types/ValidationResult'
-
-// Contract exports - Schemas
-export * from './contracts/schemas/toolSchemas'
-export * from './contracts/schemas/reporterSchemas'
-export * from './contracts/schemas/pytestSchemas'
-export * from './contracts/schemas/lintSchemas'

package/project-skills/tdd-guard/src/linters/Linter.ts

@@ -1,5 +0,0 @@
-import { LintResult } from '../contracts/schemas/lintSchemas'
-
-export interface Linter {
-  lint(filePaths: string[], configPath?: string): Promise<LintResult>
-}

package/project-skills/tdd-guard/src/linters/eslint/ESLint.test.ts

@@ -1,183 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, vi } from 'vitest'
-import { ESLint } from './ESLint'
-import { join } from 'path'
-import { LintResult } from '../../contracts/schemas/lintSchemas'
-import { hasRules, issuesFromFile } from '../../../test/utils/assertions'
-
-describe('ESLint', () => {
-  let linter: ESLint
-
-  beforeEach(() => {
-    linter = new ESLint()
-  })
-
-  test('can be instantiated', () => {
-    expect(linter).toBeDefined()
-  })
-
-  test('implements Linter interface with lint method', async () => {
-    const result = await linter.lint([])
-
-    expect(result).toBeDefined()
-    expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-  })
-
-  test('returns the file paths that were passed in', async () => {
-    const filePaths = ['src/file1.ts', 'src/file2.ts']
-    const result = await linter.lint(filePaths)
-
-    expect(result.files).toEqual(filePaths)
-  })
-
-  describe('with single file', () => {
-    let result: LintResult
-
-    beforeEach(async () => {
-      result = await linter.lint(['src/file.ts'])
-    })
-
-    test('returns empty issues array', () => {
-      expect(result.issues).toEqual([])
-    })
-
-    test('returns zero error count', () => {
-      expect(result.errorCount).toBe(0)
-    })
-
-    test('returns zero warning count', () => {
-      expect(result.warningCount).toBe(0)
-    })
-  })
-
-  describe('with files containing special characters', () => {
-    test.each([
-      ['spaces', 'src/my file with spaces.ts'],
-      ['quotes', 'src/file"with"quotes.ts'],
-      ['semicolons', 'src/file;name.ts'],
-      ['backticks', 'src/file`with`backticks.ts'],
-      ['dollar signs', 'src/file$with$dollar.ts'],
-      ['pipes', 'src/file|with|pipes.ts'],
-      ['ampersands', 'src/file&with&ampersands.ts'],
-      ['parentheses', 'src/file(with)parentheses.ts'],
-      ['command injection attempt', 'file.js"; cat /etc/passwd; echo "'],
-      ['newlines', 'src/file\nwith\nnewlines.ts'],
-      ['tabs', 'src/file\twith\ttabs.ts'],
-    ])('handles file paths with %s correctly', async (_, filePath) => {
-      const result = await linter.lint([filePath])
-
-      expect(result.files).toEqual([filePath])
-      expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-    })
-
-    test.each([
-      ['spaces', '/path with spaces/eslint.config.js'],
-      ['quotes', '/path"with"quotes/eslint.config.js'],
-      ['special chars', '/path;with&special|chars/eslint.config.js'],
-    ])('handles config paths with %s correctly', async (_, configPath) => {
-      const result = await linter.lint(['src/file.ts'], configPath)
-
-      expect(result.files).toEqual(['src/file.ts'])
-      expect(result.timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/)
-    })
-  })
-
-  describe('platform-specific shell option', () => {
-    let originalPlatform: PropertyDescriptor | undefined
-
-    beforeEach(() => {
-      originalPlatform = Object.getOwnPropertyDescriptor(process, 'platform')
-      vi.resetModules()
-    })
-
-    afterEach(() => {
-      if (originalPlatform) {
-        Object.defineProperty(process, 'platform', originalPlatform)
-      }
-      vi.clearAllMocks()
-    })
-
-    test('sets shell option to true on Windows', async () => {
-      // Windows needs shell: true to execute 'npx' (.cmd/.bat files)
-      await testShellOption('win32', true)
-    })
-
-    test('sets shell option to false on non-Windows platforms', async () => {
-      await testShellOption('darwin', false)
-    })
-  })
-
-  describe('linter.lint with artifact files', () => {
-    const artifactsDir = join(process.cwd(), 'test', 'artifacts', 'javascript')
-    const configPath = join(artifactsDir, 'eslint.config.js')
-
-    test('detects issues in file with lint problems', async () => {
-      const filePath = join(artifactsDir, 'file-with-issues.js')
-      const result = await linter.lint([filePath], configPath)
-
-      expect(result.issues.length).toBeGreaterThan(0)
-      expect(result.errorCount).toBeGreaterThan(0)
-
-      // Check for specific rules
-      const expectedRules = ['no-unused-vars', 'no-var', 'semi', 'quotes']
-      const ruleResults = hasRules(result.issues, expectedRules)
-
-      ruleResults.forEach((ruleExists) => {
-        expect(ruleExists).toBe(true)
-      })
-    })
-
-    test('finds no issues in clean file', async () => {
-      const filePath = join(artifactsDir, 'file-without-issues.js')
-      const result = await linter.lint([filePath], configPath)
-
-      expect(result.issues.length).toBe(0)
-      expect(result.errorCount).toBe(0)
-      expect(result.warningCount).toBe(0)
-    })
-
-    test('processes multiple files correctly', async () => {
-      const files = [
-        join(artifactsDir, 'file-with-issues.js'),
-        join(artifactsDir, 'file-without-issues.js'),
-      ]
-      const result = await linter.lint(files, configPath)
-
-      expect(result.files).toEqual(files)
-      expect(result.issues.length).toBeGreaterThan(0)
-
-      // Issues should only be from the file with issues
-      const cleanFileIssues = issuesFromFile(
-        result.issues,
-        'file-without-issues.js'
-      )
-      expect(cleanFileIssues.length).toBe(0)
-    })
-  })
-})
-
-// Test helper function
-async function testShellOption(platform: string, expectedShell: boolean) {
-  // Set platform to test platform-specific behavior
-  Object.defineProperty(process, 'platform', { value: platform })
-
-  let capturedOptions: { shell?: boolean } | undefined
-
-  // Mock util.promisify to capture the options passed to execFile
-  vi.doMock('util', () => ({
-    promisify:
-      () =>
-      async (_cmd: string, _args: string[], options?: { shell?: boolean }) => {
-        capturedOptions = options
-        return { stdout: '[]', stderr: '' }
-      },
-  }))
-
-  // Re-import ESLint after mocking
-  const { ESLint: MockedESLint } = await import('./ESLint')
-  const mockedLinter = new MockedESLint()
-
-  await mockedLinter.lint(['src/file.ts'])
-
-  expect(capturedOptions).toBeDefined()
-  expect(capturedOptions!.shell).toBe(expectedShell)
-}

package/project-skills/tdd-guard/src/linters/eslint/ESLint.ts

@@ -1,82 +0,0 @@
-import {
-  LintResult,
-  LintIssue,
-  ESLintResult,
-  ESLintMessage,
-} from '../../contracts/schemas/lintSchemas'
-import { execFile } from 'child_process'
-import { promisify } from 'util'
-import { Linter } from '../Linter'
-
-const execFileAsync = promisify(execFile)
-
-export class ESLint implements Linter {
-  async lint(filePaths: string[], configPath?: string): Promise<LintResult> {
-    const timestamp = new Date().toISOString()
-    const args = buildArgs(filePaths, configPath)
-
-    try {
-      await execFileAsync('npx', args, { shell: process.platform === 'win32' })
-      return createLintData(timestamp, filePaths, [])
-    } catch (error) {
-      if (!isExecError(error)) throw error
-
-      const results = parseResults(error.stdout)
-      return createLintData(timestamp, filePaths, results)
-    }
-  }
-}
-
-// Helper functions
-const buildArgs = (files: string[], configPath?: string): string[] => {
-  const args = ['eslint', ...files, '--format', 'json']
-  if (configPath) {
-    args.push('-c', configPath)
-  }
-  return args
-}
-
-const isExecError = (error: unknown): error is Error & { stdout?: string } =>
-  error !== null && typeof error === 'object' && 'stdout' in error
-
-const parseResults = (stdout?: string): ESLintResult[] => {
-  try {
-    return JSON.parse(stdout ?? '[]')
-  } catch {
-    return []
-  }
-}
-
-const createLintData = (
-  timestamp: string,
-  files: string[],
-  results: ESLintResult[]
-): LintResult => {
-  const issues = extractIssues(results)
-  return {
-    timestamp,
-    files,
-    issues,
-    errorCount: countBySeverity(issues, 'error'),
-    warningCount: countBySeverity(issues, 'warning'),
-  }
-}
-
-const extractIssues = (results: ESLintResult[]): LintIssue[] =>
-  results.flatMap((file) => (file.messages ?? []).map(toIssue(file.filePath)))
-
-const toIssue =
-  (filePath: string) =>
-  (msg: ESLintMessage): LintIssue => ({
-    file: filePath,
-    line: msg.line ?? 0,
-    column: msg.column ?? 0,
-    severity: (msg.severity === 2 ? 'error' : 'warning') as 'error' | 'warning',
-    message: msg.message,
-    rule: msg.ruleId,
-  })
-
-const countBySeverity = (
-  issues: LintIssue[],
-  severity: 'error' | 'warning'
-): number => issues.filter((i) => i.severity === severity).length