xtrm-tools 2.0.0

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

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

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

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

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

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