kanna-code 0.1.4 → 0.3.0

package/src/server/quick-response.ts

@@ -0,0 +1,124 @@
+import { query } from "@anthropic-ai/claude-agent-sdk"
+import { CodexAppServerManager } from "./codex-app-server"
+
+type JsonSchema = {
+  type: "object"
+  properties: Record<string, unknown>
+  required?: readonly string[]
+  additionalProperties?: boolean
+}
+
+export interface StructuredQuickResponseArgs<T> {
+  cwd: string
+  task: string
+  prompt: string
+  schema: JsonSchema
+  parse: (value: unknown) => T | null
+}
+
+interface QuickResponseAdapterArgs {
+  codexManager?: CodexAppServerManager
+  runClaudeStructured?: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+  runCodexStructured?: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+}
+
+function parseJsonText(value: string): unknown | null {
+  const trimmed = value.trim()
+  if (!trimmed) return null
+
+  const candidates = [trimmed]
+  const fencedMatch = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i)
+  if (fencedMatch?.[1]) {
+    candidates.unshift(fencedMatch[1].trim())
+  }
+
+  for (const candidate of candidates) {
+    try {
+      return JSON.parse(candidate)
+    } catch {
+      continue
+    }
+  }
+
+  return null
+}
+
+async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknown>, "parse">): Promise<unknown | null> {
+  const q = query({
+    prompt: args.prompt,
+    options: {
+      model: "haiku",
+      tools: [],
+      systemPrompt: "",
+      effort: "low",
+      permissionMode: "bypassPermissions",
+      outputFormat: {
+        type: "json_schema",
+        schema: args.schema,
+      },
+      env: { ...process.env },
+    },
+  })
+
+  try {
+    for await (const message of q) {
+      if ("result" in message) {
+        return (message as Record<string, unknown>).structured_output ?? null
+      }
+    }
+    return null
+  } finally {
+    q.close()
+  }
+}
+
+async function runCodexStructured(
+  codexManager: CodexAppServerManager,
+  args: Omit<StructuredQuickResponseArgs<unknown>, "parse">
+): Promise<unknown | null> {
+  const response = await codexManager.generateStructured({
+    cwd: args.cwd,
+    prompt: `${args.prompt}\n\nReturn JSON only that matches this schema:\n${JSON.stringify(args.schema, null, 2)}`,
+  })
+  if (typeof response !== "string") return null
+  return parseJsonText(response)
+}
+
+export class QuickResponseAdapter {
+  private readonly codexManager: CodexAppServerManager
+  private readonly runClaudeStructured: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+  private readonly runCodexStructured: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
+
+  constructor(args: QuickResponseAdapterArgs = {}) {
+    this.codexManager = args.codexManager ?? new CodexAppServerManager()
+    this.runClaudeStructured = args.runClaudeStructured ?? runClaudeStructured
+    this.runCodexStructured = args.runCodexStructured ?? ((structuredArgs) =>
+      runCodexStructured(this.codexManager, structuredArgs))
+  }
+
+  async generateStructured<T>(args: StructuredQuickResponseArgs<T>): Promise<T | null> {
+    const request = {
+      cwd: args.cwd,
+      task: args.task,
+      prompt: args.prompt,
+      schema: args.schema,
+    }
+
+    const claudeResult = await this.tryProvider(args.parse, () => this.runClaudeStructured(request))
+    if (claudeResult !== null) return claudeResult
+
+    return await this.tryProvider(args.parse, () => this.runCodexStructured(request))
+  }
+
+  private async tryProvider<T>(
+    parse: (value: unknown) => T | null,
+    run: () => Promise<unknown | null>
+  ): Promise<T | null> {
+    try {
+      const result = await run()
+      return result === null ? null : parse(result)
+    } catch {
+      return null
+    }
+  }
+}

package/src/server/read-models.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from "bun:test"
+import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
+import { createEmptyState } from "./events"
+
+describe("read models", () => {
+  test("include provider data in sidebar rows", () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      provider: "codex",
+      planMode: false,
+      sessionToken: "thread-1",
+      lastTurnOutcome: null,
+    })
+
+    const sidebar = deriveSidebarData(state, new Map())
+    expect(sidebar.projectGroups[0]?.chats[0]?.provider).toBe("codex")
+  })
+
+  test("includes available providers in chat snapshots", () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Project",
+      createdAt: 1,
+      updatedAt: 1,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 1,
+      provider: "claude",
+      planMode: true,
+      sessionToken: "session-1",
+      lastTurnOutcome: null,
+    })
+
+    const chat = deriveChatSnapshot(state, new Map(), "chat-1")
+    expect(chat?.runtime.provider).toBe("claude")
+    expect(chat?.availableProviders.length).toBeGreaterThan(1)
+    expect(chat?.availableProviders.find((provider) => provider.id === "codex")?.models.map((model) => model.id)).toEqual([
+      "gpt-5.4",
+      "gpt-5.3-codex",
+      "gpt-5.3-codex-spark",
+    ])
+  })
+
+  test("prefers saved project metadata over discovered entries for the same path", () => {
+    const state = createEmptyState()
+    state.projectsById.set("project-1", {
+      id: "project-1",
+      localPath: "/tmp/project",
+      title: "Saved Project",
+      createdAt: 1,
+      updatedAt: 50,
+    })
+    state.projectIdsByPath.set("/tmp/project", "project-1")
+    state.chatsById.set("chat-1", {
+      id: "chat-1",
+      projectId: "project-1",
+      title: "Chat",
+      createdAt: 1,
+      updatedAt: 75,
+      provider: "codex",
+      planMode: false,
+      sessionToken: null,
+      lastMessageAt: 100,
+      lastTurnOutcome: null,
+    })
+
+    const snapshot = deriveLocalProjectsSnapshot(state, [
+      {
+        localPath: "/tmp/project",
+        title: "Discovered Project",
+        modifiedAt: 10,
+      },
+    ], "Local Machine")
+
+    expect(snapshot.projects).toEqual([
+      {
+        localPath: "/tmp/project",
+        title: "Saved Project",
+        source: "saved",
+        lastOpenedAt: 100,
+        chatCount: 1,
+      },
+    ])
+  })
+})

package/src/server/read-models.ts

@@ -10,6 +10,7 @@ import type {
 import type { ChatRecord, StoreState } from "./events"
 import { cloneTranscriptEntries } from "./events"
 import { resolveLocalPath } from "./paths"
+import { SERVER_PROVIDERS } from "./provider-catalog"
 
 export function deriveStatus(chat: ChatRecord, activeStatus?: KannaStatus): KannaStatus {
   if (activeStatus) return activeStatus
@@ -36,6 +37,7 @@ export function deriveSidebarData(
         title: chat.title,
         status: deriveStatus(chat, activeStatuses.get(chat.id)),
         localPath: project.localPath,
+        provider: chat.provider,
         lastMessageAt: chat.lastMessageAt,
         hasAutomation: false,
       }))
@@ -109,12 +111,14 @@ export function deriveChatSnapshot(
     localPath: project.localPath,
     title: chat.title,
     status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    provider: chat.provider,
     planMode: chat.planMode,
-    resumeSessionId: chat.resumeSessionId,
+    sessionToken: chat.sessionToken,
   }
 
   return {
     runtime,
     messages: cloneTranscriptEntries(state.messagesByChatId.get(chat.id) ?? []),
+    availableProviders: [...SERVER_PROVIDERS],
   }
 }

package/src/server/server.ts

@@ -2,7 +2,7 @@ import path from "node:path"
 import { APP_NAME } from "../shared/branding"
 import { EventStore } from "./event-store"
 import { AgentCoordinator } from "./agent"
-import { discoverClaudeProjects, type DiscoveredProject } from "./discovery"
+import { discoverProjects, type DiscoveredProject } from "./discovery"
 import { getMachineDisplayName } from "./machine-name"
 import { createWsRouter, type ClientState } from "./ws-router"
 
@@ -18,7 +18,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
   let discoveredProjects: DiscoveredProject[] = []
 
   async function refreshDiscovery() {
-    discoveredProjects = discoverClaudeProjects()
+    discoveredProjects = discoverProjects()
     return discoveredProjects
   }
 

package/src/shared/protocol.ts

@@ -1,4 +1,4 @@
-import type { ChatSnapshot, LocalProjectsSnapshot, SidebarData } from "./types"
+import type { AgentProvider, ChatSnapshot, LocalProjectsSnapshot, ModelOptions, SidebarData } from "./types"
 
 export type SubscriptionTopic =
   | { type: "sidebar" }
@@ -13,7 +13,17 @@ export type ClientCommand =
   | { type: "chat.create"; projectId: string }
   | { type: "chat.rename"; chatId: string; title: string }
   | { type: "chat.delete"; chatId: string }
-  | { type: "chat.send"; chatId?: string; projectId?: string; content: string; model?: string; effort?: string; planMode?: boolean }
+  | {
+      type: "chat.send"
+      chatId?: string
+      projectId?: string
+      provider?: AgentProvider
+      content: string
+      model?: string
+      modelOptions?: ModelOptions
+      effort?: string
+      planMode?: boolean
+    }
   | { type: "chat.cancel"; chatId: string }
   | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
 

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
+  }
+}