@shareai-lab/kode 1.0.70 → 1.0.71

package/src/services/vcr.ts

@@ -0,0 +1,161 @@
+import { createHash, type UUID } from 'crypto'
+import { mkdirSync, readFileSync, writeFileSync } from 'fs'
+import { dirname } from 'path'
+import type { AssistantMessage, UserMessage } from '../query'
+import { existsSync } from 'fs'
+import { env } from '../utils/env'
+import { getCwd } from '../utils/state'
+import * as path from 'path'
+import { mapValues } from 'lodash-es'
+import type { ContentBlock } from '@anthropic-ai/sdk/resources/index.mjs'
+
+export async function withVCR(
+  messages: (UserMessage | AssistantMessage)[],
+  f: () => Promise<AssistantMessage>,
+): Promise<AssistantMessage> {
+  if (process.env.NODE_ENV !== 'test') {
+    return await f()
+  }
+
+  const dehydratedInput = mapMessages(
+    messages.map(_ => _.message.content),
+    dehydrateValue,
+  )
+  const filename = `./fixtures/${dehydratedInput.map(_ => createHash('sha1').update(JSON.stringify(_)).digest('hex').slice(0, 6)).join('-')}.json`
+
+  // Fetch cached fixture
+  if (existsSync(filename)) {
+    const cached = JSON.parse(readFileSync(filename, 'utf-8'))
+    return mapAssistantMessage(cached.output, hydrateValue)
+  }
+
+  if (env.isCI) {
+    console.warn(
+      `Anthropic API fixture missing. Re-run npm test locally, then commit the result. ${JSON.stringify({ input: dehydratedInput }, null, 2)}`,
+    )
+  }
+
+  // Create & write new fixture
+  const result = await f()
+  if (env.isCI) {
+    return result
+  }
+
+  if (!existsSync(dirname(filename))) {
+    mkdirSync(dirname(filename), { recursive: true })
+  }
+  writeFileSync(
+    filename,
+    JSON.stringify(
+      {
+        input: dehydratedInput,
+        output: mapAssistantMessage(result, dehydrateValue),
+      },
+      null,
+      2,
+    ),
+  )
+  return result
+}
+
+function mapMessages(
+  messages: (UserMessage | AssistantMessage)['message']['content'][],
+  f: (s: unknown) => unknown,
+): (UserMessage | AssistantMessage)['message']['content'][] {
+  return messages.map(_ => {
+    if (typeof _ === 'string') {
+      return f(_)
+    }
+    return _.map(_ => {
+      switch (_.type) {
+        case 'tool_result':
+          if (typeof _.content === 'string') {
+            return { ..._, content: f(_.content) }
+          }
+          if (Array.isArray(_.content)) {
+            return {
+              ..._,
+              content: _.content.map(_ => {
+                switch (_.type) {
+                  case 'text':
+                    return { ..._, text: f(_.text) }
+                  case 'image':
+                    return _
+                }
+              }),
+            }
+          }
+          return _
+        case 'text':
+          return { ..._, text: f(_.text) }
+        case 'tool_use':
+          return {
+            ..._,
+            input: mapValues(_.input as Record<string, unknown>, f),
+          }
+        case 'image':
+          return _
+      }
+    })
+  }) as (UserMessage | AssistantMessage)['message']['content'][]
+}
+
+function mapAssistantMessage(
+  message: AssistantMessage,
+  f: (s: unknown) => unknown,
+): AssistantMessage {
+  return {
+    durationMs: 'DURATION' as unknown as number,
+    costUSD: 'COST' as unknown as number,
+    uuid: 'UUID' as unknown as UUID,
+    message: {
+      ...message.message,
+      content: message.message.content
+        .map(_ => {
+          switch (_.type) {
+            case 'text':
+              return {
+                ..._,
+                text: f(_.text) as string,
+                citations: _.citations || [],
+              } // Ensure citations
+            case 'tool_use':
+              return {
+                ..._,
+                input: mapValues(_.input as Record<string, unknown>, f),
+              }
+            default:
+              return _ // Handle other block types unchanged
+          }
+        })
+        .filter(Boolean) as ContentBlock[],
+    },
+    type: 'assistant',
+  }
+}
+
+function dehydrateValue(s: unknown): unknown {
+  if (typeof s !== 'string') {
+    return s
+  }
+  const s1 = s
+    .replace(/num_files="\d+"/g, 'num_files="[NUM]"')
+    .replace(/duration_ms="\d+"/g, 'duration_ms="[DURATION]"')
+    .replace(/cost_usd="\d+"/g, 'cost_usd="[COST]"')
+    .replace(/\//g, path.sep)
+    .replaceAll(getCwd(), '[CWD]')
+  if (s1.includes('Files modified by user:')) {
+    return 'Files modified by user: [FILES]'
+  }
+  return s1
+}
+
+function hydrateValue(s: unknown): unknown {
+  if (typeof s !== 'string') {
+    return s
+  }
+  return s
+    .replaceAll('[NUM]', '1')
+    .replaceAll('[DURATION]', '100')
+    .replaceAll('[CWD]', getCwd())
+}

package/src/tools/ArchitectTool/ArchitectTool.tsx

@@ -0,0 +1,122 @@
+import type { TextBlock } from '@anthropic-ai/sdk/resources/index.mjs'
+import { Box } from 'ink'
+import * as React from 'react'
+import { z } from 'zod'
+import type { Tool } from '../../Tool'
+import { FallbackToolUseRejectedMessage } from '../../components/FallbackToolUseRejectedMessage'
+import { HighlightedCode } from '../../components/HighlightedCode'
+import { getContext } from '../../context'
+import { Message, query } from '../../query'
+import { lastX } from '../../utils/generators'
+import { createUserMessage } from '../../utils/messages'
+import { BashTool } from '../BashTool/BashTool'
+import { FileReadTool } from '../FileReadTool/FileReadTool'
+import { FileWriteTool } from '../FileWriteTool/FileWriteTool'
+import { GlobTool } from '../GlobTool/GlobTool'
+import { GrepTool } from '../GrepTool/GrepTool'
+import { LSTool } from '../lsTool/lsTool'
+import { ARCHITECT_SYSTEM_PROMPT, DESCRIPTION } from './prompt'
+
+const FS_EXPLORATION_TOOLS: Tool[] = [
+  BashTool,
+  LSTool,
+  FileReadTool,
+  FileWriteTool,
+  GlobTool,
+  GrepTool,
+]
+
+const inputSchema = z.strictObject({
+  prompt: z
+    .string()
+    .describe('The technical request or coding task to analyze'),
+  context: z
+    .string()
+    .describe('Optional context from previous conversation or system state')
+    .optional(),
+})
+
+export const ArchitectTool = {
+  name: 'Architect',
+  async description() {
+    return DESCRIPTION
+  },
+  inputSchema,
+  isReadOnly() {
+    return true
+  },
+  isConcurrencySafe() {
+    return true // ArchitectTool is read-only, safe for concurrent execution
+  },
+  userFacingName() {
+    return 'Architect'
+  },
+  async isEnabled() {
+    return false
+  },
+  needsPermissions() {
+    return false
+  },
+  async *call({ prompt, context }, toolUseContext, canUseTool) {
+    const content = context
+      ? `<context>${context}</context>\n\n${prompt}`
+      : prompt
+
+    const userMessage = createUserMessage(content)
+
+    const messages: Message[] = [userMessage]
+
+    // We only allow the file exploration tools to be used in the architect tool
+    const allowedTools = (toolUseContext.options.tools ?? []).filter(_ =>
+      FS_EXPLORATION_TOOLS.map(_ => _.name).includes(_.name),
+    )
+
+    const lastResponse = await lastX(
+      query(
+        messages,
+        [ARCHITECT_SYSTEM_PROMPT],
+        await getContext(),
+        canUseTool,
+        {
+          ...toolUseContext,
+          options: { ...toolUseContext.options, tools: allowedTools },
+        },
+      ),
+    )
+
+    if (lastResponse.type !== 'assistant') {
+      throw new Error(`Invalid response from API`)
+    }
+
+    const data = lastResponse.message.content.filter(_ => _.type === 'text')
+    yield {
+      type: 'result',
+      data,
+      resultForAssistant: this.renderResultForAssistant(data),
+    }
+  },
+  async prompt() {
+    return DESCRIPTION
+  },
+  renderResultForAssistant(data) {
+    return data
+  },
+  renderToolUseMessage(input) {
+    return Object.entries(input)
+      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+      .join(', ')
+  },
+  renderToolResultMessage(content) {
+    return (
+      <Box flexDirection="column" gap={1}>
+        <HighlightedCode
+          code={content.map(_ => _.text).join('\n')}
+          language="markdown"
+        />
+      </Box>
+    )
+  },
+  renderToolUseRejectedMessage() {
+    return <FallbackToolUseRejectedMessage />
+  },
+} satisfies Tool<typeof inputSchema, TextBlock[]>

package/src/tools/ArchitectTool/prompt.ts

@@ -0,0 +1,15 @@
+export const ARCHITECT_SYSTEM_PROMPT = `You are an expert software architect. Your role is to analyze technical requirements and produce clear, actionable implementation plans.
+These plans will then be carried out by a junior software engineer so you need to be specific and detailed. However do not actually write the code, just explain the plan.
+
+Follow these steps for each request:
+1. Carefully analyze requirements to identify core functionality and constraints
+2. Define clear technical approach with specific technologies and patterns
+3. Break down implementation into concrete, actionable steps at the appropriate level of abstraction
+
+Keep responses focused, specific and actionable. 
+
+IMPORTANT: Do not ask the user if you should implement the changes at the end. Just provide the plan as described above.
+IMPORTANT: Do not attempt to write the code or use any string modification tools. Just provide the plan.`
+
+export const DESCRIPTION =
+  'Your go-to tool for any technical or coding task. Analyzes requirements and breaks them down into clear, actionable implementation steps. Use this whenever you need help planning how to implement a feature, solve a technical problem, or structure your code.'