kanna-code 0.1.3 → 0.2.0

package/src/shared/tools.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test"
+import { hydrateToolResult, normalizeToolCall } from "./tools"
+
+describe("normalizeToolCall", () => {
+  test("maps AskUserQuestion input to typed questions", () => {
+    const tool = normalizeToolCall({
+      toolName: "AskUserQuestion",
+      toolId: "tool-1",
+      input: {
+        questions: [
+          {
+            question: "Which runtime?",
+            header: "Runtime",
+            options: [{ label: "Codex", description: "Use Codex" }],
+          },
+        ],
+      },
+    })
+
+    expect(tool.toolKind).toBe("ask_user_question")
+    if (tool.toolKind !== "ask_user_question") throw new Error("unexpected tool kind")
+    expect(tool.input.questions[0]?.question).toBe("Which runtime?")
+  })
+
+  test("maps Bash snake_case input to camelCase", () => {
+    const tool = normalizeToolCall({
+      toolName: "Bash",
+      toolId: "tool-2",
+      input: {
+        command: "pwd",
+        timeout: 5000,
+        run_in_background: true,
+      },
+    })
+
+    expect(tool.toolKind).toBe("bash")
+    if (tool.toolKind !== "bash") throw new Error("unexpected tool kind")
+    expect(tool.input.timeoutMs).toBe(5000)
+    expect(tool.input.runInBackground).toBe(true)
+  })
+
+  test("maps unknown MCP tools to mcp_generic", () => {
+    const tool = normalizeToolCall({
+      toolName: "mcp__sentry__search_issues",
+      toolId: "tool-3",
+      input: { query: "regression" },
+    })
+
+    expect(tool.toolKind).toBe("mcp_generic")
+    if (tool.toolKind !== "mcp_generic") throw new Error("unexpected tool kind")
+    expect(tool.input.server).toBe("sentry")
+    expect(tool.input.tool).toBe("search_issues")
+  })
+})
+
+describe("hydrateToolResult", () => {
+  test("hydrates AskUserQuestion answers", () => {
+    const tool = normalizeToolCall({
+      toolName: "AskUserQuestion",
+      toolId: "tool-1",
+      input: { questions: [] },
+    })
+
+    const result = hydrateToolResult(tool, JSON.stringify({ answers: { runtime: "codex" } }))
+    expect(result).toEqual({ answers: { runtime: "codex" } })
+  })
+
+  test("hydrates ExitPlanMode decisions", () => {
+    const tool = normalizeToolCall({
+      toolName: "ExitPlanMode",
+      toolId: "tool-2",
+      input: { plan: "Do the thing" },
+    })
+
+    const result = hydrateToolResult(tool, { confirmed: true, clearContext: true })
+    expect(result).toEqual({ confirmed: true, clearContext: true, message: undefined })
+  })
+
+  test("hydrates Read file text results", () => {
+    const tool = normalizeToolCall({
+      toolName: "Read",
+      toolId: "tool-3",
+      input: { file_path: "/tmp/example.ts" },
+    })
+
+    expect(hydrateToolResult(tool, "line 1\nline 2")).toBe("line 1\nline 2")
+  })
+})

package/src/shared/tools.ts

@@ -0,0 +1,233 @@
+import type {
+  AskUserQuestionItem,
+  AskUserQuestionToolResult,
+  ExitPlanModeToolResult,
+  HydratedToolCall,
+  NormalizedToolCall,
+  ReadFileToolResult,
+  TodoItem,
+} from "./types"
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null
+  return value as Record<string, unknown>
+}
+
+export function normalizeToolCall(args: {
+  toolName: string
+  toolId: string
+  input: Record<string, unknown>
+}): NormalizedToolCall {
+  const { toolName, toolId, input } = args
+
+  switch (toolName) {
+    case "AskUserQuestion":
+      return {
+        kind: "tool",
+        toolKind: "ask_user_question",
+        toolName,
+        toolId,
+        input: {
+          questions: Array.isArray(input.questions) ? (input.questions as AskUserQuestionItem[]) : [],
+        },
+        rawInput: input,
+      }
+    case "ExitPlanMode":
+      return {
+        kind: "tool",
+        toolKind: "exit_plan_mode",
+        toolName,
+        toolId,
+        input: {
+          plan: typeof input.plan === "string" ? input.plan : undefined,
+          summary: typeof input.summary === "string" ? input.summary : undefined,
+        },
+        rawInput: input,
+      }
+    case "TodoWrite":
+      return {
+        kind: "tool",
+        toolKind: "todo_write",
+        toolName,
+        toolId,
+        input: {
+          todos: Array.isArray(input.todos) ? (input.todos as TodoItem[]) : [],
+        },
+        rawInput: input,
+      }
+    case "Skill":
+      return {
+        kind: "tool",
+        toolKind: "skill",
+        toolName,
+        toolId,
+        input: {
+          skill: typeof input.skill === "string" ? input.skill : "",
+        },
+        rawInput: input,
+      }
+    case "Glob":
+      return {
+        kind: "tool",
+        toolKind: "glob",
+        toolName,
+        toolId,
+        input: {
+          pattern: typeof input.pattern === "string" ? input.pattern : "",
+        },
+        rawInput: input,
+      }
+    case "Grep":
+      return {
+        kind: "tool",
+        toolKind: "grep",
+        toolName,
+        toolId,
+        input: {
+          pattern: typeof input.pattern === "string" ? input.pattern : "",
+          outputMode: typeof input.output_mode === "string" ? input.output_mode : undefined,
+        },
+        rawInput: input,
+      }
+    case "Bash":
+      return {
+        kind: "tool",
+        toolKind: "bash",
+        toolName,
+        toolId,
+        input: {
+          command: typeof input.command === "string" ? input.command : "",
+          description: typeof input.description === "string" ? input.description : undefined,
+          timeoutMs: typeof input.timeout === "number" ? input.timeout : undefined,
+          runInBackground: Boolean(input.run_in_background),
+        },
+        rawInput: input,
+      }
+    case "WebSearch":
+      return {
+        kind: "tool",
+        toolKind: "web_search",
+        toolName,
+        toolId,
+        input: {
+          query: typeof input.query === "string" ? input.query : "",
+        },
+        rawInput: input,
+      }
+    case "Read":
+      return {
+        kind: "tool",
+        toolKind: "read_file",
+        toolName,
+        toolId,
+        input: {
+          filePath: typeof input.file_path === "string" ? input.file_path : "",
+        },
+        rawInput: input,
+      }
+    case "Write":
+      return {
+        kind: "tool",
+        toolKind: "write_file",
+        toolName,
+        toolId,
+        input: {
+          filePath: typeof input.file_path === "string" ? input.file_path : "",
+          content: typeof input.content === "string" ? input.content : "",
+        },
+        rawInput: input,
+      }
+    case "Edit":
+      return {
+        kind: "tool",
+        toolKind: "edit_file",
+        toolName,
+        toolId,
+        input: {
+          filePath: typeof input.file_path === "string" ? input.file_path : "",
+          oldString: typeof input.old_string === "string" ? input.old_string : "",
+          newString: typeof input.new_string === "string" ? input.new_string : "",
+        },
+        rawInput: input,
+      }
+  }
+
+  const mcpMatch = toolName.match(/^mcp__(.+?)__(.+)$/)
+  if (mcpMatch) {
+    return {
+      kind: "tool",
+      toolKind: "mcp_generic",
+      toolName,
+      toolId,
+      input: {
+        server: mcpMatch[1],
+        tool: mcpMatch[2],
+        payload: input,
+      },
+      rawInput: input,
+    }
+  }
+
+  if (typeof input.subagent_type === "string") {
+    return {
+      kind: "tool",
+      toolKind: "subagent_task",
+      toolName,
+      toolId,
+      input: {
+        subagentType: input.subagent_type,
+      },
+      rawInput: input,
+    }
+  }
+
+  return {
+    kind: "tool",
+    toolKind: "unknown_tool",
+    toolName,
+    toolId,
+    input: {
+      payload: input,
+    },
+    rawInput: input,
+  }
+}
+
+function parseJsonValue(value: unknown): unknown {
+  if (typeof value !== "string") return value
+  try {
+    return JSON.parse(value)
+  } catch {
+    return value
+  }
+}
+
+export function hydrateToolResult(tool: NormalizedToolCall, raw: unknown): HydratedToolCall["result"] {
+  const parsed = parseJsonValue(raw)
+
+  switch (tool.toolKind) {
+    case "ask_user_question": {
+      const record = asRecord(parsed)
+      const answers = asRecord(record?.answers) ?? (record ? record : {})
+      return { answers: Object.fromEntries(Object.entries(answers).map(([key, value]) => [key, String(value)])) } satisfies AskUserQuestionToolResult
+    }
+    case "exit_plan_mode": {
+      const record = asRecord(parsed)
+      return {
+        confirmed: typeof record?.confirmed === "boolean" ? record.confirmed : undefined,
+        clearContext: typeof record?.clearContext === "boolean" ? record.clearContext : undefined,
+        message: typeof record?.message === "string" ? record.message : undefined,
+      } satisfies ExitPlanModeToolResult
+    }
+    case "read_file":
+      if (typeof parsed === "string") {
+        return parsed
+      }
+      const record = asRecord(parsed)
+      return {
+        content: typeof record?.content === "string" ? record.content : JSON.stringify(parsed, null, 2),
+      } satisfies ReadFileToolResult
+    default:
+      return parsed
+  }
+}