xtrm-tools 2.3.0 → 2.4.0

package/project-skills/tdd-guard/src/contracts/schemas/toolSchemas.test.ts

@@ -1,563 +0,0 @@
-import { describe, test, expect } from 'vitest'
-import {
-  TodoSchema,
-  EditSchema,
-  MultiEditSchema,
-  WriteSchema,
-  TodoWriteSchema,
-  EditOperationSchema,
-  MultiEditOperationSchema,
-  WriteOperationSchema,
-  TodoWriteOperationSchema,
-  ToolOperationSchema,
-  FileModificationSchema,
-  isEditOperation,
-  isMultiEditOperation,
-  isWriteOperation,
-  isTodoWriteOperation,
-  isFileModification,
-  UserPromptSubmitSchema,
-  SessionStartSchema,
-} from './toolSchemas'
-import { testData } from '@testUtils'
-
-describe('Tool-specific schemas', () => {
-  describe('SessionStartSchema', () => {
-    test.each([
-      {
-        description: 'with startup source',
-        data: testData.sessionStart({ source: 'startup' }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with resume source',
-        data: testData.sessionStart({ source: 'resume' }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with clear source',
-        data: testData.sessionStart({ source: 'clear' }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with invalid source',
-        data: { ...testData.sessionStart(), source: 'invalid' },
-        expectedSuccess: false,
-      },
-      {
-        description: 'with wrong hook_event_name',
-        data: { ...testData.sessionStart(), hook_event_name: 'PreToolUse' },
-        expectedSuccess: false,
-      },
-      {
-        description: 'without source',
-        data: testData.sessionStartWithout(['source']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ data, expectedSuccess }) => {
-      const result = SessionStartSchema.safeParse(data)
-      expect(result.success).toBe(expectedSuccess)
-    })
-  })
-  describe('UserPromptSubmitSchema', () => {
-    test.each([
-      {
-        description: 'with valid data',
-        data: testData.userPromptSubmit(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with different prompt',
-        data: testData.userPromptSubmit({ prompt: 'tdd-guard off' }),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with wrong hook_event_name',
-        data: testData.userPromptSubmit({ hook_event_name: 'PreToolUse' }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without prompt',
-        data: testData.userPromptSubmitWithout(['prompt']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without cwd',
-        data: testData.userPromptSubmitWithout(['cwd']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without session_id',
-        data: testData.userPromptSubmitWithout(['session_id']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without transcript_path',
-        data: testData.userPromptSubmitWithout(['transcript_path']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ data, expectedSuccess }) => {
-      const result = UserPromptSubmitSchema.safeParse(data)
-      expect(result.success).toBe(expectedSuccess)
-    })
-  })
-
-  describe('TodoSchema', () => {
-    test.each([
-      {
-        description: 'without content',
-        todo: testData.todoWithout(['content']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without status',
-        todo: testData.todoWithout(['status']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without priority',
-        todo: testData.todoWithout(['priority']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without id',
-        todo: testData.todoWithout(['id']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with everything',
-        todo: testData.todo(),
-        expectedSuccess: true,
-      },
-    ])('$description', ({ todo, expectedSuccess }) => {
-      const result = TodoSchema.safeParse(todo)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(todo)
-      }
-    })
-  })
-
-  describe('EditSchema', () => {
-    test.each([
-      {
-        description: 'without file_path',
-        edit: testData.editWithout(['file_path']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without old_string',
-        edit: testData.editWithout(['old_string']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without new_string',
-        edit: testData.editWithout(['new_string']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with everything',
-        edit: testData.edit(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with replace_all true',
-        edit: testData.edit({ replace_all: true }),
-        expectedSuccess: true,
-      },
-    ])('$description', ({ edit, expectedSuccess }) => {
-      const result = EditSchema.safeParse(edit)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(edit)
-      }
-    })
-  })
-
-  describe('MultiEditSchema', () => {
-    test.each([
-      {
-        description: 'with valid multi-edit',
-        multiEdit: testData.multiEdit(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'without file_path',
-        multiEdit: testData.multiEditWithout(['file_path']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without edits',
-        multiEdit: testData.multiEditWithout(['edits']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'with empty edits array',
-        multiEdit: testData.multiEdit({ edits: [] }),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ multiEdit, expectedSuccess }) => {
-      const result = MultiEditSchema.safeParse(multiEdit)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(multiEdit)
-      }
-    })
-  })
-
-  describe('WriteSchema', () => {
-    test.each([
-      {
-        description: 'with valid write',
-        write: testData.write(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'without file_path',
-        write: testData.writeWithout(['file_path']),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without content',
-        write: testData.writeWithout(['content']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ write, expectedSuccess }) => {
-      const result = WriteSchema.safeParse(write)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(write)
-      }
-    })
-  })
-
-  describe('TodoWriteSchema', () => {
-    test.each([
-      {
-        description: 'with valid todo write',
-        todoWrite: testData.todoWrite(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with empty todos array',
-        todoWrite: testData.todoWrite({ todos: [] }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without todos',
-        todoWrite: testData.todoWriteWithout(['todos']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ todoWrite, expectedSuccess }) => {
-      const result = TodoWriteSchema.safeParse(todoWrite)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(todoWrite)
-      }
-    })
-  })
-
-  describe('EditOperationSchema', () => {
-    test.each([
-      {
-        description: 'with valid edit operation',
-        editOperation: testData.editOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with wrong tool_name',
-        editOperation: testData.invalidEditOperation({ tool_name: 'Write' }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without tool_input',
-        editOperation: testData.editOperationWithout(['tool_input']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ editOperation, expectedSuccess }) => {
-      const result = EditOperationSchema.safeParse(editOperation)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(editOperation)
-      }
-    })
-  })
-
-  describe('MultiEditOperationSchema', () => {
-    test.each([
-      {
-        description: 'with valid multi-edit operation',
-        multiEditOperation: testData.multiEditOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with wrong tool_name',
-        multiEditOperation: testData.invalidMultiEditOperation({
-          tool_name: 'Edit',
-        }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without tool_input',
-        multiEditOperation: testData.multiEditOperationWithout(['tool_input']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ multiEditOperation, expectedSuccess }) => {
-      const result = MultiEditOperationSchema.safeParse(multiEditOperation)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(multiEditOperation)
-      }
-    })
-  })
-
-  describe('WriteOperationSchema', () => {
-    test.each([
-      {
-        description: 'with valid write operation',
-        writeOperation: testData.writeOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with wrong tool_name',
-        writeOperation: testData.invalidWriteOperation({ tool_name: 'Edit' }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without tool_input',
-        writeOperation: testData.writeOperationWithout(['tool_input']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ writeOperation, expectedSuccess }) => {
-      const result = WriteOperationSchema.safeParse(writeOperation)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(writeOperation)
-      }
-    })
-  })
-
-  describe('TodoWriteOperationSchema', () => {
-    test.each([
-      {
-        description: 'with valid todo write operation',
-        todoWriteOperation: testData.todoWriteOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with wrong tool_name',
-        todoWriteOperation: testData.invalidTodoWriteOperation({
-          tool_name: 'Edit',
-        }),
-        expectedSuccess: false,
-      },
-      {
-        description: 'without tool_input',
-        todoWriteOperation: testData.todoWriteOperationWithout(['tool_input']),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ todoWriteOperation, expectedSuccess }) => {
-      const result = TodoWriteOperationSchema.safeParse(todoWriteOperation)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(todoWriteOperation)
-      }
-    })
-  })
-
-  describe('ToolOperationSchema', () => {
-    test.each([
-      {
-        description: 'with valid Edit operation',
-        toolOperation: testData.editOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with valid MultiEdit operation',
-        toolOperation: testData.multiEditOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with valid Write operation',
-        toolOperation: testData.writeOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with valid TodoWrite operation',
-        toolOperation: testData.todoWriteOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with unknown tool_name',
-        toolOperation: { tool_name: 'Unknown', tool_input: {} },
-        expectedSuccess: false,
-      },
-    ])('$description', ({ toolOperation, expectedSuccess }) => {
-      const result = ToolOperationSchema.safeParse(toolOperation)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(toolOperation)
-      }
-    })
-  })
-
-  describe('FileModificationSchema', () => {
-    test.each([
-      {
-        description: 'with valid Edit operation',
-        fileModification: testData.editOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with valid MultiEdit operation',
-        fileModification: testData.multiEditOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with valid Write operation',
-        fileModification: testData.writeOperation(),
-        expectedSuccess: true,
-      },
-      {
-        description: 'with TodoWrite operation (should reject)',
-        fileModification: testData.todoWriteOperation(),
-        expectedSuccess: false,
-      },
-    ])('$description', ({ fileModification, expectedSuccess }) => {
-      const result = FileModificationSchema.safeParse(fileModification)
-      expect(result.success).toBe(expectedSuccess)
-
-      if (expectedSuccess && result.success) {
-        expect(result.data).toEqual(fileModification)
-      }
-    })
-  })
-})
-
-describe('Type guards', () => {
-  // Create test data for all operation types
-  const editOperation = testData.editOperation()
-  const multiEditOperation = testData.multiEditOperation()
-  const writeOperation = testData.writeOperation()
-  const todoWriteOperation = testData.todoWriteOperation()
-
-  describe('isEditOperation', () => {
-    test.each([
-      { operation: editOperation, operationType: 'Edit', expected: true },
-      {
-        operation: multiEditOperation,
-        operationType: 'MultiEdit',
-        expected: false,
-      },
-      { operation: writeOperation, operationType: 'Write', expected: false },
-      {
-        operation: todoWriteOperation,
-        operationType: 'TodoWrite',
-        expected: false,
-      },
-    ])(
-      'returns $expected for $operationType operation',
-      ({ operation, expected }) => {
-        expect(isEditOperation(operation)).toBe(expected)
-      }
-    )
-  })
-
-  describe('isMultiEditOperation', () => {
-    test.each([
-      { operation: editOperation, operationType: 'Edit', expected: false },
-      {
-        operation: multiEditOperation,
-        operationType: 'MultiEdit',
-        expected: true,
-      },
-      { operation: writeOperation, operationType: 'Write', expected: false },
-      {
-        operation: todoWriteOperation,
-        operationType: 'TodoWrite',
-        expected: false,
-      },
-    ])(
-      'returns $expected for $operationType operation',
-      ({ operation, expected }) => {
-        expect(isMultiEditOperation(operation)).toBe(expected)
-      }
-    )
-  })
-
-  describe('isWriteOperation', () => {
-    test.each([
-      { operation: editOperation, operationType: 'Edit', expected: false },
-      {
-        operation: multiEditOperation,
-        operationType: 'MultiEdit',
-        expected: false,
-      },
-      { operation: writeOperation, operationType: 'Write', expected: true },
-      {
-        operation: todoWriteOperation,
-        operationType: 'TodoWrite',
-        expected: false,
-      },
-    ])(
-      'returns $expected for $operationType operation',
-      ({ operation, expected }) => {
-        expect(isWriteOperation(operation)).toBe(expected)
-      }
-    )
-  })
-
-  describe('isTodoWriteOperation', () => {
-    test.each([
-      { operation: editOperation, operationType: 'Edit', expected: false },
-      {
-        operation: multiEditOperation,
-        operationType: 'MultiEdit',
-        expected: false,
-      },
-      { operation: writeOperation, operationType: 'Write', expected: false },
-      {
-        operation: todoWriteOperation,
-        operationType: 'TodoWrite',
-        expected: true,
-      },
-    ])(
-      'returns $expected for $operationType operation',
-      ({ operation, expected }) => {
-        expect(isTodoWriteOperation(operation)).toBe(expected)
-      }
-    )
-  })
-
-  describe('isFileModification', () => {
-    test.each([
-      { operation: editOperation, operationType: 'Edit', expected: true },
-      {
-        operation: multiEditOperation,
-        operationType: 'MultiEdit',
-        expected: true,
-      },
-      { operation: writeOperation, operationType: 'Write', expected: true },
-      {
-        operation: todoWriteOperation,
-        operationType: 'TodoWrite',
-        expected: false,
-      },
-    ])(
-      'returns $expected for $operationType operation',
-      ({ operation, expected }) => {
-        expect(isFileModification(operation)).toBe(expected)
-      }
-    )
-  })
-})

package/project-skills/tdd-guard/src/contracts/schemas/toolSchemas.ts

@@ -1,140 +0,0 @@
-import { z } from 'zod'
-
-// Base Hook Context
-export const HookContextSchema = z.object({
-  session_id: z.string(),
-  transcript_path: z.string(),
-  hook_event_name: z.string(),
-})
-
-export const HookDataSchema = HookContextSchema.extend({
-  tool_name: z.string(),
-  tool_input: z.unknown(),
-})
-
-export type HookData = z.infer<typeof HookDataSchema>
-
-// UserPromptSubmit Schema
-export const UserPromptSubmitSchema = HookContextSchema.extend({
-  prompt: z.string(),
-  cwd: z.string(),
-}).refine((data) => data.hook_event_name === 'UserPromptSubmit')
-
-export type UserPromptSubmit = z.infer<typeof UserPromptSubmitSchema>
-
-// SessionStart Schema
-export const SessionStartSchema = HookContextSchema.extend({
-  hook_event_name: z.literal('SessionStart'),
-  source: z.enum(['startup', 'resume', 'clear']),
-})
-
-export type SessionStart = z.infer<typeof SessionStartSchema>
-
-// Tool Input Schemas
-export const TodoSchema = z.object({
-  content: z.string(),
-  status: z.enum(['pending', 'in_progress', 'completed']),
-  priority: z.enum(['high', 'medium', 'low']),
-  id: z.string(),
-})
-
-export type Todo = z.infer<typeof TodoSchema>
-
-export const EditSchema = z.object({
-  file_path: z.string(),
-  old_string: z.string(),
-  new_string: z.string(),
-  replace_all: z.boolean().optional(),
-})
-
-export type Edit = z.infer<typeof EditSchema>
-
-const EditEntrySchema = z.object({
-  old_string: z.string(),
-  new_string: z.string(),
-  replace_all: z.boolean().optional(),
-})
-
-export const MultiEditSchema = z.object({
-  file_path: z.string(),
-  edits: z.array(EditEntrySchema).min(1),
-})
-
-export type MultiEdit = z.infer<typeof MultiEditSchema>
-
-export const WriteSchema = z.object({
-  file_path: z.string(),
-  content: z.string(),
-})
-
-export type Write = z.infer<typeof WriteSchema>
-
-export const TodoWriteSchema = z.object({
-  todos: z.array(TodoSchema).min(1),
-})
-
-export type TodoWrite = z.infer<typeof TodoWriteSchema>
-
-// Tool Operation Schemas
-export const EditOperationSchema = HookContextSchema.extend({
-  tool_name: z.literal('Edit'),
-  tool_input: EditSchema,
-})
-
-export const MultiEditOperationSchema = HookContextSchema.extend({
-  tool_name: z.literal('MultiEdit'),
-  tool_input: MultiEditSchema,
-})
-
-export const WriteOperationSchema = HookContextSchema.extend({
-  tool_name: z.literal('Write'),
-  tool_input: WriteSchema,
-})
-
-export const TodoWriteOperationSchema = HookContextSchema.extend({
-  tool_name: z.literal('TodoWrite'),
-  tool_input: TodoWriteSchema,
-})
-
-export type EditOperation = z.infer<typeof EditOperationSchema>
-export type MultiEditOperation = z.infer<typeof MultiEditOperationSchema>
-export type WriteOperation = z.infer<typeof WriteOperationSchema>
-export type TodoWriteOperation = z.infer<typeof TodoWriteOperationSchema>
-
-// Discriminated Unions
-export const ToolOperationSchema = z.discriminatedUnion('tool_name', [
-  EditOperationSchema,
-  MultiEditOperationSchema,
-  WriteOperationSchema,
-  TodoWriteOperationSchema,
-])
-
-export type ToolOperation = z.infer<typeof ToolOperationSchema>
-
-export const FileModificationSchema = z.discriminatedUnion('tool_name', [
-  EditOperationSchema,
-  MultiEditOperationSchema,
-  WriteOperationSchema,
-])
-
-export type FileModification = z.infer<typeof FileModificationSchema>
-
-// Type Guards
-export const isEditOperation = (op: ToolOperation): op is EditOperation =>
-  op.tool_name === 'Edit'
-
-export const isMultiEditOperation = (
-  op: ToolOperation
-): op is MultiEditOperation => op.tool_name === 'MultiEdit'
-
-export const isWriteOperation = (op: ToolOperation): op is WriteOperation =>
-  op.tool_name === 'Write'
-
-export const isTodoWriteOperation = (
-  op: ToolOperation
-): op is TodoWriteOperation => op.tool_name === 'TodoWrite'
-
-export const isFileModification = (op: ToolOperation): op is FileModification =>
-  op.tool_name === 'Edit' ||
-  op.tool_name === 'MultiEdit' ||
-  op.tool_name === 'Write'

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

@@ -1 +0,0 @@
-export type ClientType = 'api' | 'cli' | 'sdk'

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

@@ -1,12 +0,0 @@
-import { ClientType } from './ClientType'
-
-export type ConfigOptions = {
-  mode?: 'production' | 'test'
-  projectRoot?: string
-  useSystemClaude?: boolean
-  anthropicApiKey?: string
-  modelType?: string
-  modelVersion?: string
-  linterType?: string
-  validationClient?: ClientType
-}