xtrm-tools 2.2.0 → 2.4.0

package/project-skills/tdd-guard/src/validation/context/context.ts

@@ -1,155 +0,0 @@
-import { Context, ProcessedLintData } from '../../contracts/types/Context'
-import { Config } from '../../config/Config'
-import {
-  isEditOperation,
-  isMultiEditOperation,
-  isWriteOperation,
-  ToolOperation,
-  EditOperation,
-  MultiEditOperation,
-  WriteOperation,
-  Todo,
-} from '../../contracts/schemas/toolSchemas'
-import { TestResultsProcessor } from '../../processors'
-import { formatLintDataForContext } from '../../processors/lintProcessor'
-
-// Import core prompts
-import { SYSTEM_PROMPT } from '../prompts/system-prompt'
-import { RULES } from '../prompts/rules'
-import { FILE_TYPES } from '../prompts/file-types'
-import { RESPONSE } from '../prompts/response'
-
-// Import operation-specific context
-import { EDIT } from '../prompts/operations/edit'
-import { MULTI_EDIT } from '../prompts/operations/multi-edit'
-import { WRITE } from '../prompts/operations/write'
-import { TODOS } from '../prompts/tools/todos'
-import { TEST_OUTPUT } from '../prompts/tools/test-output'
-import { LINT_RESULTS } from '../prompts/tools/lint-results'
-
-export function generateDynamicContext(
-  context: Context,
-  config?: Config
-): string {
-  const operation: ToolOperation = JSON.parse(context.modifications)
-  const effectiveConfig = config ?? new Config()
-
-  const sections: string[] = [
-    // 1. Core sections (system prompt only for CLI)
-    getSystemPrompt(effectiveConfig),
-    context.instructions ?? RULES,
-    FILE_TYPES,
-
-    // 2. Operation-specific context and changes
-    formatOperation(operation),
-
-    // 3. Additional context
-    formatTestSection(context.test),
-    formatTodoSection(context.todo),
-    formatLintSection(context.lint),
-
-    // 4. Response format
-    RESPONSE,
-  ]
-
-  return sections.filter(Boolean).join('\n')
-}
-
-function formatOperation(operation: ToolOperation): string {
-  if (isEditOperation(operation)) {
-    return EDIT + formatEditOperation(operation)
-  }
-
-  if (isMultiEditOperation(operation)) {
-    return MULTI_EDIT + formatMultiEditOperation(operation)
-  }
-
-  if (isWriteOperation(operation)) {
-    return WRITE + formatWriteOperation(operation)
-  }
-
-  return ''
-}
-
-function formatEditOperation(operation: EditOperation): string {
-  return (
-    formatSection('File Path', operation.tool_input.file_path) +
-    formatSection('Old Content', operation.tool_input.old_string) +
-    formatSection('New Content', operation.tool_input.new_string)
-  )
-}
-
-function formatMultiEditOperation(operation: MultiEditOperation): string {
-  const editsFormatted = operation.tool_input.edits
-    .map((edit, index) => formatEdit(edit, index + 1))
-    .join('')
-
-  return `${formatSection(
-    'File Path',
-    operation.tool_input.file_path
-  )}\n### Edits\n${editsFormatted}`
-}
-
-function formatWriteOperation(operation: WriteOperation): string {
-  return (
-    formatSection('File Path', operation.tool_input.file_path) +
-    formatSection('New File Content', operation.tool_input.content)
-  )
-}
-
-function formatEdit(
-  edit: { old_string: string; new_string: string },
-  index: number
-): string {
-  return (
-    `\n#### Edit ${index}:\n` +
-    `**Old Content:**\n${codeBlock(edit.old_string)}` +
-    `**New Content:**\n${codeBlock(edit.new_string)}`
-  )
-}
-
-function formatTestSection(testOutput?: string): string {
-  if (!testOutput) return ''
-
-  const output = testOutput.trim()
-    ? new TestResultsProcessor().process(testOutput)
-    : 'No test output available. Tests must be run before implementing.'
-
-  return TEST_OUTPUT + codeBlock(output)
-}
-
-function formatTodoSection(todoJson?: string): string {
-  if (!todoJson) return ''
-
-  const todoOperation = JSON.parse(todoJson)
-  const todos: Todo[] = todoOperation.tool_input?.todos ?? []
-
-  const todoItems = todos
-    .map(
-      (todo, index) =>
-        `${index + 1}. [${todo.status}] ${todo.content} (${todo.priority})`
-    )
-    .join('\n')
-
-  return `${TODOS}${todoItems}\n`
-}
-
-function formatLintSection(lintData?: ProcessedLintData): string {
-  if (!lintData) return ''
-
-  const formattedLintData = formatLintDataForContext(lintData)
-  return LINT_RESULTS + codeBlock(formattedLintData)
-}
-
-function formatSection(title: string, content: string): string {
-  return `\n### ${title}\n${codeBlock(content)}`
-}
-
-function codeBlock(content: string): string {
-  return `\`\`\`\n${content}\n\`\`\`\n`
-}
-
-function getSystemPrompt(config: Config): string {
-  // Only the CLI client requires the system prompt in the query
-  return config.validationClient === 'cli' ? SYSTEM_PROMPT : ''
-}

package/project-skills/tdd-guard/src/validation/models/AnthropicApi.test.ts

@@ -1,171 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from 'vitest'
-import { AnthropicApi } from './AnthropicApi'
-import Anthropic from '@anthropic-ai/sdk'
-import { Config } from '../../config/Config'
-import { SYSTEM_PROMPT } from '../prompts/system-prompt'
-
-vi.mock('@anthropic-ai/sdk')
-
-// Test constants
-const DEFAULT_TEST_PROMPT = 'test prompt'
-
-describe('AnthropicApi', () => {
-  let sut: Awaited<ReturnType<typeof createSut>>
-  let client: AnthropicApi
-  const apiKey = 'test-api-key'
-  const modelVersion = 'claude-3-5-sonnet-20241022'
-
-  beforeEach(() => {
-    sut = createSut(apiKey, modelVersion)
-    client = sut.client
-  })
-
-  test('should implement IModelClient interface', () => {
-    expect(client.ask).toBeDefined()
-  })
-
-  test('should accept optional Config in constructor', () => {
-    const config = new Config()
-    const apiClient = new AnthropicApi(config)
-    expect(apiClient).toBeDefined()
-  })
-
-  test('should create Anthropic client with API key from config', () => {
-    expect(sut.wasCreatedWithApiKey(apiKey)).toBe(true)
-  })
-
-  test('uses model version from config', async () => {
-    const call = await sut.askAndGetCall()
-    expect(call.model).toBe(modelVersion)
-  })
-
-  test('includes system prompt in API call', async () => {
-    const call = await sut.askAndGetCall()
-    expect(call.system).toBe(SYSTEM_PROMPT)
-  })
-
-  test('sets max tokens to 1024', async () => {
-    const call = await sut.askAndGetCall()
-    expect(call.max_tokens).toBe(1024)
-  })
-
-  test('passes prompt as user message', async () => {
-    const prompt = 'Does this follow TDD?'
-    const call = await sut.askAndGetCall(prompt)
-    expect(call.messages).toEqual([
-      {
-        role: 'user',
-        content: prompt,
-      },
-    ])
-  })
-
-  test('ask method should return text from response', async () => {
-    const expectedText = 'Model response text'
-    const result = await sut.askWithResponse(expectedText)
-
-    expect(result).toBe(expectedText)
-  })
-
-  test('ask method should throw error when API call fails', async () => {
-    await expect(sut.askWithError('API error')).rejects.toThrow('API error')
-  })
-
-  test('ask method should handle empty content array', async () => {
-    sut.mockCreate.mockResolvedValue({ content: [] })
-
-    await expect(client.ask(DEFAULT_TEST_PROMPT)).rejects.toThrow()
-  })
-
-  test('ask method should handle missing text property', async () => {
-    sut.mockCreate.mockResolvedValue({ content: [{ type: 'image' }] })
-
-    await expect(client.ask(DEFAULT_TEST_PROMPT)).rejects.toThrow()
-  })
-})
-
-// Test Helpers
-interface MessageCreateParams {
-  model: string
-  system: string
-  max_tokens: number
-  messages: Array<{ role: string; content: string }>
-}
-
-function createSut(apiKey?: string, modelVersion?: string) {
-  vi.clearAllMocks()
-
-  const mockCreate = vi.fn().mockResolvedValue({
-    content: [{ text: 'Model response' }],
-  })
-
-  const mockAnthropicConstructor = vi.mocked(Anthropic)
-  mockAnthropicConstructor.mockImplementation(
-    () =>
-      ({
-        messages: {
-          create: mockCreate,
-        },
-      }) as unknown as Anthropic
-  )
-
-  const config = new Config({ anthropicApiKey: apiKey, modelVersion })
-  const client = new AnthropicApi(config)
-
-  const mockResponse = (text: string): void => {
-    mockCreate.mockResolvedValue({
-      content: [{ text }],
-    })
-  }
-
-  const getLastCall = (): MessageCreateParams => {
-    const lastCall = mockCreate.mock.calls[mockCreate.mock.calls.length - 1]
-    const params = lastCall[0]
-    return {
-      model: params.model,
-      system: params.system,
-      max_tokens: params.max_tokens,
-      messages: params.messages,
-    }
-  }
-
-  const askAndGetCall = async (
-    prompt = DEFAULT_TEST_PROMPT
-  ): Promise<MessageCreateParams> => {
-    await client.ask(prompt)
-    return getLastCall()
-  }
-
-  const wasCreatedWithApiKey = (key: string): boolean => {
-    return mockAnthropicConstructor.mock.calls.some(
-      (call) => call[0]?.apiKey === key
-    )
-  }
-
-  const askWithResponse = async (
-    responseText: string
-  ): Promise<string | undefined> => {
-    mockResponse(responseText)
-    return client.ask(DEFAULT_TEST_PROMPT)
-  }
-
-  const askWithError = async (
-    errorMessage: string
-  ): Promise<string | undefined> => {
-    mockCreate.mockRejectedValue(new Error(errorMessage))
-    return client.ask(DEFAULT_TEST_PROMPT)
-  }
-
-  return {
-    client,
-    mockCreate,
-    mockAnthropicConstructor,
-    config,
-    mockResponse,
-    getLastCall,
-    askAndGetCall,
-    wasCreatedWithApiKey,
-    askWithResponse,
-    askWithError,
-  }
-}

package/project-skills/tdd-guard/src/validation/models/AnthropicApi.ts

@@ -1,49 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk'
-import { Config } from '../../config/Config'
-import { IModelClient } from '../../contracts/types/ModelClient'
-import { SYSTEM_PROMPT } from '../prompts/system-prompt'
-
-export class AnthropicApi implements IModelClient {
-  private readonly config: Config
-  private readonly client: Anthropic
-
-  constructor(config?: Config) {
-    this.config = config ?? new Config()
-    this.client = new Anthropic({
-      apiKey: this.config.anthropicApiKey,
-    })
-  }
-
-  async ask(prompt: string): Promise<string> {
-    const response = await this.client.messages.create({
-      model: this.config.modelVersion,
-      system: SYSTEM_PROMPT,
-      max_tokens: 1024,
-      messages: [
-        {
-          role: 'user',
-          content: prompt,
-        },
-      ],
-    })
-
-    return extractTextFromResponse(response)
-  }
-}
-
-interface MessageResponse {
-  content: Array<{ text?: string; type?: string }>
-}
-
-function extractTextFromResponse(response: MessageResponse): string {
-  if (response.content.length === 0) {
-    throw new Error('No content in response')
-  }
-
-  const firstContent = response.content[0]
-  if (!('text' in firstContent) || !firstContent.text) {
-    throw new Error('Response content does not contain text')
-  }
-
-  return firstContent.text
-}

package/project-skills/tdd-guard/src/validation/models/ClaudeAgentSdk.test.ts

@@ -1,167 +0,0 @@
-import { describe, test, expect, vi, beforeEach } from 'vitest'
-import { ClaudeAgentSdk } from './ClaudeAgentSdk'
-import { Config } from '../../config/Config'
-import { IModelClient } from '../../contracts/types/ModelClient'
-import { query, type SDKResultMessage } from '@anthropic-ai/claude-agent-sdk'
-import { SYSTEM_PROMPT } from '../prompts/system-prompt'
-
-describe('ClaudeAgentSdk', () => {
-  describe('constructor', () => {
-    test('implements the IModelClient interface', () => {
-      const client: IModelClient = new ClaudeAgentSdk()
-      expect(client.ask).toBeDefined()
-    })
-
-    test('accepts optional Config in constructor', () => {
-      const config = new Config()
-      const client = new ClaudeAgentSdk(config)
-      expect(client['config']).toBe(config)
-    })
-
-    test('uses default Config when not provided', () => {
-      const client = new ClaudeAgentSdk()
-      expect(client['config']).toBeInstanceOf(Config)
-    })
-
-    test('accepts query function as second parameter', () => {
-      const customQuery = vi.fn()
-      const config = new Config()
-      const client = new ClaudeAgentSdk(config, customQuery)
-      expect(client['queryFn']).toBe(customQuery)
-    })
-
-    test('uses query from @anthropic-ai/claude-agent-sdk when not provided', () => {
-      const client = new ClaudeAgentSdk()
-      expect(client['queryFn']).toBe(query)
-    })
-  })
-
-  describe('query invocation', () => {
-    const prompt = 'test prompt'
-    const message = createSDKResultMessage()
-    const modelVersion = 'claude-opus-4-1'
-    const config = new Config({ modelVersion })
-    const { client, getUsedOptions, getUsedPrompt } = setupClient(
-      message,
-      config
-    )
-
-    beforeEach(async () => {
-      await client.ask(prompt)
-    })
-
-    test('calls queryFn with correct prompt', async () => {
-      expect(getUsedPrompt()).toBe(prompt)
-    })
-
-    test('sets maxTurns to 1', async () => {
-      expect(getUsedOptions().maxTurns).toBe(1)
-    })
-
-    test('sets allowedTools to empty array', async () => {
-      expect(getUsedOptions().allowedTools).toEqual([])
-    })
-
-    test('sets disallowedTools to prevent file operations and other tools', async () => {
-      const expectedDisallowedTools = [
-        'Read',
-        'Edit',
-        'MultiEdit',
-        'Write',
-        'Grep',
-        'Glob',
-        'Bash',
-        'WebFetch',
-        'WebSearch',
-        'Task',
-        'TodoWrite',
-      ]
-      expect(getUsedOptions().disallowedTools).toEqual(expectedDisallowedTools)
-    })
-
-    test('sets maxThinkingTokens to 0', async () => {
-      expect(getUsedOptions().maxThinkingTokens).toBe(0)
-    })
-
-    test('uses model version from config', async () => {
-      expect(getUsedOptions().model).toBe(modelVersion)
-    })
-
-    test('sets strictMcpConfig to true', async () => {
-      expect(getUsedOptions().strictMcpConfig).toBe(true)
-    })
-
-    test('uses SYSTEM_PROMPT for systemPrompt', async () => {
-      expect(getUsedOptions().systemPrompt).toBe(SYSTEM_PROMPT)
-    })
-
-    test('sets cwd to config dataDir', async () => {
-      // Prevents hook trigggers and keeps queries out of project history
-      expect(getUsedOptions().cwd).toBe(config.dataDir)
-    })
-  })
-
-  describe('result handling', () => {
-    test('returns result from successful response', async () => {
-      const { client } = setupClient({ result: 'test result' })
-
-      await expect(client.ask('test')).resolves.toBe('test result')
-    })
-
-    test('throws error when query returns error subtype', async () => {
-      const { client } = setupClient({ subtype: 'error_max_turns' })
-
-      await expect(client.ask('test')).rejects.toThrow(
-        'Claude Agent SDK error: error_max_turns'
-      )
-    })
-
-    test('throws error when no result message is received', async () => {
-      const { client } = setupClient({ type: 'other', data: 'something' })
-
-      await expect(client.ask('test')).rejects.toThrow(
-        'Claude Agent SDK error: No result message received'
-      )
-    })
-  })
-})
-
-// Test Helpers
-function setupClient(
-  messageOverrides: Partial<SDKResultMessage> = {},
-  config: Config = new Config()
-) {
-  const customQuery = createMockQuery(messageOverrides)
-  const client = new ClaudeAgentSdk(config, customQuery)
-
-  const getLastCall = () => customQuery.mock.lastCall![0]
-  const getUsedOptions = () => getLastCall().options
-  const getUsedPrompt = () => getLastCall().prompt
-
-  return {
-    client,
-    customQuery,
-    config,
-    getUsedOptions,
-    getUsedPrompt,
-  }
-}
-
-function createMockQuery(messageOverrides: Partial<SDKResultMessage> = {}) {
-  return vi.fn().mockReturnValue({
-    async *[Symbol.asyncIterator]() {
-      yield createSDKResultMessage(messageOverrides)
-    },
-  })
-}
-
-function createSDKResultMessage(
-  overrides: Partial<SDKResultMessage> = {}
-): SDKResultMessage {
-  return {
-    type: 'result',
-    subtype: 'success',
-    result: 'default result',
-    ...overrides,
-  } as SDKResultMessage
-}

package/project-skills/tdd-guard/src/validation/models/ClaudeAgentSdk.ts

@@ -1,54 +0,0 @@
-import { Config } from '../../config/Config'
-import { query, type Options } from '@anthropic-ai/claude-agent-sdk'
-import { IModelClient } from '../../contracts/types/ModelClient'
-import { SYSTEM_PROMPT } from '../prompts/system-prompt'
-
-export class ClaudeAgentSdk implements IModelClient {
-  constructor(
-    private readonly config: Config = new Config(),
-    private readonly queryFn: typeof query = query
-  ) {}
-
-  async ask(prompt: string): Promise<string> {
-    const queryResult = this.queryFn({
-      prompt,
-      options: this.getQueryOptions(),
-    })
-
-    for await (const message of queryResult) {
-      if (message.type !== 'result') continue
-
-      if (message.subtype === 'success') {
-        return message.result
-      }
-      throw new Error(`Claude Agent SDK error: ${message.subtype}`)
-    }
-
-    throw new Error('Claude Agent SDK error: No result message received')
-  }
-
-  private getQueryOptions(): Options {
-    return {
-      maxTurns: 1,
-      systemPrompt: SYSTEM_PROMPT,
-      allowedTools: [],
-      disallowedTools: [
-        'Read',
-        'Edit',
-        'MultiEdit',
-        'Write',
-        'Grep',
-        'Glob',
-        'Bash',
-        'WebFetch',
-        'WebSearch',
-        'Task',
-        'TodoWrite',
-      ],
-      maxThinkingTokens: 0,
-      model: this.config.modelVersion,
-      strictMcpConfig: true,
-      cwd: this.config.dataDir,
-    }
-  }
-}