xtrm-tools 2.0.0

package/project-skills/tdd-guard/test/utils/factories/contextFactory.ts

@@ -0,0 +1,30 @@
+import { Context } from '../../../src/contracts/types/Context'
+import { TEST_DEFAULTS } from './testDefaults'
+
+/**
+ * Creates a test Context object with sensible defaults
+ */
+export function context(overrides?: Partial<Context>): Context {
+  return {
+    modifications: TEST_DEFAULTS.modifications,
+    todo: JSON.stringify([TEST_DEFAULTS.todo]),
+    test: TEST_DEFAULTS.test,
+    ...overrides,
+  }
+}
+
+/**
+ * Creates a test Context object without specific fields
+ */
+export function contextWithout<K extends keyof Context>(
+  ...omitFields: K[]
+): Omit<Context, K> {
+  const fullContext = context()
+  const result = { ...fullContext }
+
+  for (const field of omitFields) {
+    delete result[field]
+  }
+
+  return result as Omit<Context, K>
+}

package/project-skills/tdd-guard/test/utils/factories/editFactory.ts

@@ -0,0 +1,82 @@
+/**
+ * Factory functions for creating Edit and EditOperation test data
+ */
+
+import type {
+  Edit,
+  EditOperation,
+} from '../../../src/contracts/schemas/toolSchemas'
+import { hookDataDefaults, omit } from './helpers'
+import { TEST_DEFAULTS } from './testDefaults'
+
+/**
+ * Creates a single edit object
+ * @param params - Optional parameters for the edit
+ */
+export const edit = (params?: Partial<Edit>): Edit => {
+  const defaults = TEST_DEFAULTS.edit
+  const base = params ?? {}
+
+  const result: Edit = {
+    file_path: base.file_path ?? defaults.file_path,
+    old_string: base.old_string ?? defaults.old_string,
+    new_string: base.new_string ?? defaults.new_string,
+  }
+
+  if (base.replace_all !== undefined) {
+    result.replace_all = base.replace_all
+  }
+
+  return result
+}
+
+/**
+ * Creates an edit object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the edit
+ */
+export const editWithout = <K extends keyof Edit>(
+  keys: K[],
+  params?: Partial<Edit>
+): Omit<Edit, K> => {
+  const fullEdit = edit(params)
+  return omit(fullEdit, keys)
+}
+
+/**
+ * Creates a single edit operation object
+ * @param params - Optional parameters for the edit operation
+ */
+export const editOperation = (
+  params?: Partial<EditOperation>
+): EditOperation => ({
+  ...hookDataDefaults(),
+  tool_name: 'Edit',
+  tool_input: params?.tool_input ?? edit(),
+})
+
+/**
+ * Creates an edit operation object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the edit operation
+ */
+export const editOperationWithout = <K extends keyof EditOperation>(
+  keys: K[],
+  params?: Partial<EditOperation>
+): Omit<EditOperation, K> => {
+  const fullEditOperation = editOperation(params)
+  return omit(fullEditOperation, keys)
+}
+
+/**
+ * Creates an invalid edit operation object for testing
+ * @param params - Parameters including invalid values
+ */
+export const invalidEditOperation = (params: {
+  tool_name?: string
+  tool_input?: unknown
+}): Record<string, unknown> => ({
+  ...hookDataDefaults(),
+  tool_name: params.tool_name ?? 'Edit',
+  tool_input: params.tool_input ?? edit(),
+})

package/project-skills/tdd-guard/test/utils/factories/helpers.test.ts

@@ -0,0 +1,46 @@
+import { describe, test, expect } from 'vitest'
+import { pick, omit } from './helpers'
+
+describe('Helper functions', () => {
+  describe('pick', () => {
+    const testObject = {
+      a: 1,
+      b: 'two',
+      c: true,
+      d: { nested: 'value' },
+    }
+
+    test('picks single property', () => {
+      const result = pick(testObject, ['a'])
+
+      expect(result).toEqual({ a: 1 })
+    })
+
+    test('picks multiple properties', () => {
+      const result = pick(testObject, ['a', 'c'])
+
+      expect(result).toEqual({ a: 1, c: true })
+    })
+  })
+
+  describe('omit', () => {
+    const testObject = {
+      a: 1,
+      b: 'two',
+      c: true,
+      d: { nested: 'value' },
+    }
+
+    test('omits single property', () => {
+      const result = omit(testObject, ['a'])
+
+      expect(result).toEqual({ b: 'two', c: true, d: { nested: 'value' } })
+    })
+
+    test('omits multiple properties', () => {
+      const result = omit(testObject, ['a', 'c'])
+
+      expect(result).toEqual({ b: 'two', d: { nested: 'value' } })
+    })
+  })
+})

package/project-skills/tdd-guard/test/utils/factories/helpers.ts

@@ -0,0 +1,46 @@
+/**
+ * Helper functions for object manipulation in test factories
+ */
+
+import { TEST_DEFAULTS } from './testDefaults'
+
+/**
+ * Default hook data fields for all operations
+ */
+export const hookDataDefaults = (): {
+  session_id: string
+  transcript_path: string
+  hook_event_name: string
+} => ({
+  session_id: TEST_DEFAULTS.hookData.session_id,
+  transcript_path: TEST_DEFAULTS.hookData.transcript_path,
+  hook_event_name: TEST_DEFAULTS.hookData.hook_event_name,
+})
+
+/**
+ * Creates a new object with only the specified properties
+ * @param obj - The source object
+ * @param keys - Array of property keys to include
+ * @returns A new object with only the specified properties
+ */
+export const pick = <T, K extends keyof T>(obj: T, keys: K[]): Pick<T, K> => {
+  const result = {} as Pick<T, K>
+  keys.forEach((key) => {
+    result[key] = obj[key]
+  })
+  return result
+}
+
+/**
+ * Creates a new object with specified properties omitted
+ * @param obj - The source object
+ * @param keys - Array of property keys to omit
+ * @returns A new object without the specified properties
+ */
+export const omit = <T, K extends keyof T>(obj: T, keys: K[]): Omit<T, K> => {
+  const result = { ...obj }
+  keys.forEach((key) => {
+    delete result[key]
+  })
+  return result as Omit<T, K>
+}

package/project-skills/tdd-guard/test/utils/factories/lintFactory.ts

@@ -0,0 +1,352 @@
+/**
+ * Factory functions for creating Lint test data
+ */
+
+import type {
+  LintIssue,
+  LintData,
+  LintResult,
+  ESLintMessage,
+  ESLintResult,
+  GolangciLintPosition,
+  GolangciLintIssue,
+  GolangciLintResult,
+} from '../../../src/contracts/schemas/lintSchemas'
+import { omit } from './helpers'
+
+/**
+ * Creates a single lint issue object
+ * @param params - Optional parameters for the lint issue
+ */
+export const lintIssue = (params?: Partial<LintIssue>): LintIssue => {
+  const defaults: LintIssue = {
+    file: '/src/example.ts',
+    line: 15,
+    column: 5,
+    severity: 'error',
+    message: 'Function has too high complexity',
+    rule: 'complexity',
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint issue object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the lint issue
+ */
+export const lintIssueWithout = <K extends keyof LintIssue>(
+  keys: K[],
+  params?: Partial<LintIssue>
+): Omit<LintIssue, K> => {
+  const fullLintIssue = lintIssue(params)
+  return omit(fullLintIssue, keys)
+}
+
+/**
+ * Creates a lint result object
+ * @param params - Optional parameters for the lint result
+ */
+export const lintResult = (params?: Partial<LintResult>): LintResult => {
+  const defaults: LintResult = {
+    timestamp: '2024-01-01T00:00:00Z',
+    files: ['/src/example.ts'],
+    issues: [lintIssue()],
+    errorCount: 1,
+    warningCount: 0,
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint result object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the lint result
+ */
+export const lintResultWithout = <K extends keyof LintResult>(
+  keys: K[],
+  params?: Partial<LintResult>
+): Omit<LintResult, K> => {
+  const fullLintResult = lintResult(params)
+  return omit(fullLintResult, keys)
+}
+
+/**
+ * Creates a lint data object
+ * @param params - Optional parameters for the lint data
+ */
+export const lintData = (params?: Partial<LintData>): LintData => {
+  const defaults: LintData = {
+    timestamp: '2024-01-01T00:00:00Z',
+    files: ['/src/example.ts'],
+    issues: [lintIssue()],
+    errorCount: 1,
+    warningCount: 0,
+    hasNotifiedAboutLintIssues: false,
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint data object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the lint data
+ */
+export const lintDataWithout = <K extends keyof LintData>(
+  keys: K[],
+  params?: Partial<LintData>
+): Omit<LintData, K> => {
+  const fullLintData = lintData(params)
+  return omit(fullLintData, keys)
+}
+
+/**
+ * Creates an ESLint message object
+ * @param params - Optional parameters for the ESLint message
+ */
+export const eslintMessage = (
+  params?: Partial<ESLintMessage>
+): ESLintMessage => {
+  const defaults: ESLintMessage = {
+    line: 10,
+    column: 5,
+    severity: 2,
+    message: 'Unexpected var, use let or const instead',
+    ruleId: 'no-var',
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates an ESLint message object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the ESLint message
+ */
+export const eslintMessageWithout = <K extends keyof ESLintMessage>(
+  keys: K[],
+  params?: Partial<ESLintMessage>
+): Omit<ESLintMessage, K> => {
+  const fullMessage = eslintMessage(params)
+  return omit(fullMessage, keys)
+}
+
+/**
+ * Creates an ESLint result object
+ * @param params - Optional parameters for the ESLint result
+ */
+export const eslintResult = (params?: Partial<ESLintResult>): ESLintResult => {
+  const defaults: ESLintResult = {
+    filePath: '/src/example.ts',
+    messages: [eslintMessage()],
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates an ESLint result object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the ESLint result
+ */
+export const eslintResultWithout = <K extends keyof ESLintResult>(
+  keys: K[],
+  params?: Partial<ESLintResult>
+): Omit<ESLintResult, K> => {
+  const fullResult = eslintResult(params)
+  return omit(fullResult, keys)
+}
+
+/**
+ * Creates a lint result object with no errors
+ * @param params - Optional parameters to override defaults
+ */
+export const lintResultWithoutErrors = (
+  params?: Partial<LintResult>
+): LintResult => {
+  return {
+    timestamp: new Date().toISOString(),
+    files: params?.files ?? [],
+    issues: [],
+    errorCount: 0,
+    warningCount: 0,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint result object with errors
+ * @param params - Optional parameters to override defaults
+ */
+export const lintResultWithError = (
+  params?: Partial<LintResult>
+): LintResult => {
+  const defaultIssue = lintIssue()
+  return {
+    timestamp: new Date().toISOString(),
+    files: params?.files ?? ['/src/example.ts'],
+    issues: params?.issues ?? [defaultIssue],
+    errorCount: params?.errorCount ?? 1,
+    warningCount: params?.warningCount ?? 0,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint data object with notification flag set (for testing notification state)
+ * @param params - Optional parameters to override defaults
+ */
+export const lintDataWithNotificationFlag = (
+  params?: Partial<LintData>
+): LintData => {
+  return {
+    timestamp: new Date().toISOString(),
+    files: [],
+    issues: [],
+    errorCount: 0,
+    warningCount: 0,
+    hasNotifiedAboutLintIssues: true,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint data object with errors
+ * @param params - Optional parameters to override defaults
+ */
+export const lintDataWithError = (params?: Partial<LintData>): LintData => {
+  const baseLintResult = lintResultWithError()
+  return {
+    ...baseLintResult,
+    hasNotifiedAboutLintIssues: false,
+    ...params,
+  }
+}
+
+/**
+ * Creates a lint data object without errors
+ * @param params - Optional parameters to override defaults
+ */
+export const lintDataWithoutErrors = (params?: Partial<LintData>): LintData => {
+  const baseLintResult = lintResultWithoutErrors()
+  return {
+    ...baseLintResult,
+    hasNotifiedAboutLintIssues: false,
+    ...params,
+  }
+}
+
+/**
+ * Creates a GolangciLint position object
+ * @param params - Optional parameters for the position
+ */
+export const golangciLintPosition = (
+  params?: Partial<GolangciLintPosition>
+): GolangciLintPosition => {
+  const defaults: GolangciLintPosition = {
+    Filename: '/path/to/file.go',
+    Line: 10,
+    Column: 5,
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates a GolangciLint position object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the position
+ */
+export const golangciLintPositionWithout = <
+  K extends keyof GolangciLintPosition,
+>(
+  keys: K[],
+  params?: Partial<GolangciLintPosition>
+): Omit<GolangciLintPosition, K> => {
+  const fullPosition = golangciLintPosition(params)
+  return omit(fullPosition, keys)
+}
+
+/**
+ * Creates a GolangciLint issue object
+ * @param params - Optional parameters for the issue
+ */
+export const golangciLintIssue = (
+  params?: Partial<GolangciLintIssue>
+): GolangciLintIssue => {
+  const defaults: GolangciLintIssue = {
+    FromLinter: 'typecheck',
+    Text: 'undefined: variable',
+    Severity: 'error',
+    Pos: golangciLintPosition(),
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates a GolangciLint issue object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the issue
+ */
+export const golangciLintIssueWithout = <K extends keyof GolangciLintIssue>(
+  keys: K[],
+  params?: Partial<GolangciLintIssue>
+): Omit<GolangciLintIssue, K> => {
+  const fullIssue = golangciLintIssue(params)
+  return omit(fullIssue, keys)
+}
+
+/**
+ * Creates a GolangciLint result object
+ * @param params - Optional parameters for the result
+ */
+export const golangciLintResult = (
+  params?: Partial<GolangciLintResult>
+): GolangciLintResult => {
+  const defaults: GolangciLintResult = {
+    Issues: [golangciLintIssue()],
+  }
+
+  return {
+    ...defaults,
+    ...params,
+  }
+}
+
+/**
+ * Creates a GolangciLint result object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the result
+ */
+export const golangciLintResultWithout = <K extends keyof GolangciLintResult>(
+  keys: K[],
+  params?: Partial<GolangciLintResult>
+): Omit<GolangciLintResult, K> => {
+  const fullResult = golangciLintResult(params)
+  return omit(fullResult, keys)
+}

package/project-skills/tdd-guard/test/utils/factories/modelClientProviderFactory.ts

@@ -0,0 +1,21 @@
+import { ModelClientProvider } from '../../../src/providers/ModelClientProvider'
+import { IModelClient } from '../../../src/contracts/types/ModelClient'
+import { Config } from '../../../src/config/Config'
+
+export function modelClientProvider(): ModelClientProvider {
+  return new MockModelClientProvider()
+}
+
+class MockModelClientProvider extends ModelClientProvider {
+  getModelClient(config?: Config): IModelClient {
+    const actualConfig = config ?? new Config()
+
+    return {
+      ask: async () =>
+        JSON.stringify({
+          decision: undefined,
+          reason: `Using mock model client with modelType: ${actualConfig.modelType}`,
+        }),
+    }
+  }
+}

package/project-skills/tdd-guard/test/utils/factories/multiEditFactory.ts

@@ -0,0 +1,79 @@
+/**
+ * Factory functions for creating MultiEdit and MultiEditOperation test data
+ */
+
+import type {
+  MultiEdit,
+  MultiEditOperation,
+} from '../../../src/contracts/schemas/toolSchemas'
+import { hookDataDefaults, omit } from './helpers'
+import { TEST_DEFAULTS } from './testDefaults'
+
+/**
+ * Creates a single multi-edit object
+ * @param params - Optional parameters for the multi-edit
+ */
+export const multiEdit = (params?: Partial<MultiEdit>): MultiEdit => ({
+  file_path: params?.file_path ?? TEST_DEFAULTS.multiEdit.file_path,
+  edits: params?.edits ?? [
+    {
+      old_string: TEST_DEFAULTS.multiEdit.edits[0].old_string,
+      new_string: TEST_DEFAULTS.multiEdit.edits[0].new_string,
+    },
+    {
+      old_string: TEST_DEFAULTS.multiEdit.edits[1].old_string,
+      new_string: TEST_DEFAULTS.multiEdit.edits[1].new_string,
+    },
+  ],
+})
+
+/**
+ * Creates a multi-edit object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the multi-edit
+ */
+export const multiEditWithout = <K extends keyof MultiEdit>(
+  keys: K[],
+  params?: Partial<MultiEdit>
+): Omit<MultiEdit, K> => {
+  const fullMultiEdit = multiEdit(params)
+  return omit(fullMultiEdit, keys)
+}
+
+/**
+ * Creates a single multi-edit operation object
+ * @param params - Optional parameters for the multi-edit operation
+ */
+export const multiEditOperation = (
+  params?: Partial<MultiEditOperation>
+): MultiEditOperation => ({
+  ...hookDataDefaults(),
+  tool_name: 'MultiEdit',
+  tool_input: params?.tool_input ?? multiEdit(),
+})
+
+/**
+ * Creates a multi-edit operation object with specified properties omitted
+ * @param keys - Array of property keys to omit
+ * @param params - Optional parameters for the multi-edit operation
+ */
+export const multiEditOperationWithout = <K extends keyof MultiEditOperation>(
+  keys: K[],
+  params?: Partial<MultiEditOperation>
+): Omit<MultiEditOperation, K> => {
+  const fullMultiEditOperation = multiEditOperation(params)
+  return omit(fullMultiEditOperation, keys)
+}
+
+/**
+ * Creates an invalid multi-edit operation object for testing
+ * @param params - Parameters including invalid values
+ */
+export const invalidMultiEditOperation = (params: {
+  tool_name?: string
+  tool_input?: unknown
+}): Record<string, unknown> => ({
+  ...hookDataDefaults(),
+  tool_name: params.tool_name ?? 'MultiEdit',
+  tool_input: params.tool_input ?? multiEdit(),
+})