kanna-code 0.1.4 → 0.3.0

package/src/server/event-store.ts

@@ -2,7 +2,7 @@ import { appendFile, mkdir } from "node:fs/promises"
 import { homedir } from "node:os"
 import path from "node:path"
 import { getDataDir, LOG_PREFIX } from "../shared/branding"
-import type { TranscriptEntry } from "../shared/types"
+import type { AgentProvider, TranscriptEntry } from "../shared/types"
 import { STORE_VERSION } from "../shared/types"
 import {
   type ChatEvent,
@@ -29,6 +29,7 @@ export class EventStore {
   readonly dataDir = DATA_DIR
   readonly state: StoreState = createEmptyState()
   private writeChain = Promise.resolve()
+  private storageReset = false
 
   async initialize() {
     await mkdir(DATA_DIR, { recursive: true })
@@ -50,14 +51,31 @@ export class EventStore {
     }
   }
 
+  private async clearStorage() {
+    if (this.storageReset) return
+    this.storageReset = true
+    this.resetState()
+    await Promise.all([
+      Bun.write(SNAPSHOT_PATH, ""),
+      Bun.write(PROJECTS_LOG, ""),
+      Bun.write(CHATS_LOG, ""),
+      Bun.write(MESSAGES_LOG, ""),
+      Bun.write(TURNS_LOG, ""),
+    ])
+  }
+
   private async loadSnapshot() {
     const file = Bun.file(SNAPSHOT_PATH)
     if (!(await file.exists())) return
 
     try {
-      const parsed = (await file.json()) as SnapshotFile
+      const text = await file.text()
+      if (!text.trim()) return
+      const parsed = JSON.parse(text) as SnapshotFile
       if (parsed.v !== STORE_VERSION) {
-        throw new Error(`Unsupported snapshot version ${String(parsed.v)}`)
+        console.warn(`${LOG_PREFIX} Resetting local chat history for store version ${STORE_VERSION}`)
+        await this.clearStorage()
+        return
       }
       for (const project of parsed.projects) {
         this.state.projectsById.set(project.id, { ...project })
@@ -70,8 +88,8 @@ export class EventStore {
         this.state.messagesByChatId.set(messageSet.chatId, cloneTranscriptEntries(messageSet.entries))
       }
     } catch (error) {
-      console.warn(`${LOG_PREFIX} Failed to load snapshot, rebuilding from logs:`, error)
-      this.resetState()
+      console.warn(`${LOG_PREFIX} Failed to load snapshot, resetting local history:`, error)
+      await this.clearStorage()
     }
   }
 
@@ -83,9 +101,13 @@ export class EventStore {
   }
 
   private async replayLogs() {
+    if (this.storageReset) return
     await this.replayLog<ProjectEvent>(PROJECTS_LOG)
+    if (this.storageReset) return
     await this.replayLog<ChatEvent>(CHATS_LOG)
+    if (this.storageReset) return
     await this.replayLog<MessageEvent>(MESSAGES_LOG)
+    if (this.storageReset) return
     await this.replayLog<TurnEvent>(TURNS_LOG)
   }
 
@@ -108,14 +130,21 @@ export class EventStore {
       const line = lines[index].trim()
       if (!line) continue
       try {
-        const event = JSON.parse(line) as TEvent
-        this.applyEvent(event)
+        const event = JSON.parse(line) as Partial<StoreEvent>
+        if (event.v !== STORE_VERSION) {
+          console.warn(`${LOG_PREFIX} Resetting local history from incompatible event log`)
+          await this.clearStorage()
+          return
+        }
+        this.applyEvent(event as StoreEvent)
       } catch (error) {
         if (index === lastNonEmpty) {
           console.warn(`${LOG_PREFIX} Ignoring corrupt trailing line in ${path.basename(filePath)}`)
           return
         }
-        throw error
+        console.warn(`${LOG_PREFIX} Failed to replay ${path.basename(filePath)}, resetting local history:`, error)
+        await this.clearStorage()
+        return
       }
     }
   }
@@ -150,8 +179,9 @@ export class EventStore {
           title: event.title,
           createdAt: event.timestamp,
           updatedAt: event.timestamp,
+          provider: null,
           planMode: false,
-          resumeSessionId: null,
+          sessionToken: null,
           lastTurnOutcome: null,
         }
         this.state.chatsById.set(chat.id, chat)
@@ -171,6 +201,13 @@ export class EventStore {
         chat.updatedAt = event.timestamp
         break
       }
+      case "chat_provider_set": {
+        const chat = this.state.chatsById.get(event.chatId)
+        if (!chat) break
+        chat.provider = event.provider
+        chat.updatedAt = event.timestamp
+        break
+      }
       case "chat_plan_mode_set": {
         const chat = this.state.chatsById.get(event.chatId)
         if (!chat) break
@@ -181,15 +218,8 @@ export class EventStore {
       case "message_appended": {
         const chat = this.state.chatsById.get(event.chatId)
         if (chat) {
-          // Only update lastMessageAt for user-sent messages so the sidebar
-          // sorts by "last sent" rather than "last received".
-          try {
-            const parsed = JSON.parse(event.entry.message)
-            if (parsed.type === "user_prompt") {
-              chat.lastMessageAt = event.entry.createdAt
-            }
-          } catch {
-            // non-JSON entry, skip
+          if (event.entry.kind === "user_prompt") {
+            chat.lastMessageAt = event.entry.createdAt
           }
           chat.updatedAt = Math.max(chat.updatedAt, event.entry.createdAt)
         }
@@ -225,10 +255,10 @@ export class EventStore {
         chat.lastTurnOutcome = "cancelled"
         break
       }
-      case "resume_session_set": {
+      case "session_token_set": {
         const chat = this.state.chatsById.get(event.chatId)
         if (!chat) break
-        chat.resumeSessionId = event.sessionId
+        chat.sessionToken = event.sessionToken
         chat.updatedAt = event.timestamp
         break
       }
@@ -326,6 +356,19 @@ export class EventStore {
     await this.append(CHATS_LOG, event)
   }
 
+  async setChatProvider(chatId: string, provider: AgentProvider) {
+    const chat = this.requireChat(chatId)
+    if (chat.provider === provider) return
+    const event: ChatEvent = {
+      v: STORE_VERSION,
+      type: "chat_provider_set",
+      timestamp: Date.now(),
+      chatId,
+      provider,
+    }
+    await this.append(CHATS_LOG, event)
+  }
+
   async setPlanMode(chatId: string, planMode: boolean) {
     const chat = this.requireChat(chatId)
     if (chat.planMode === planMode) return
@@ -396,15 +439,15 @@ export class EventStore {
     await this.append(TURNS_LOG, event)
   }
 
-  async setResumeSession(chatId: string, sessionId: string | null) {
+  async setSessionToken(chatId: string, sessionToken: string | null) {
     const chat = this.requireChat(chatId)
-    if (chat.resumeSessionId === sessionId) return
+    if (chat.sessionToken === sessionToken) return
     const event: TurnEvent = {
       v: STORE_VERSION,
-      type: "resume_session_set",
+      type: "session_token_set",
       timestamp: Date.now(),
       chatId,
-      sessionId,
+      sessionToken,
     }
     await this.append(TURNS_LOG, event)
   }
@@ -460,19 +503,23 @@ export class EventStore {
         entries: cloneTranscriptEntries(entries),
       })),
     }
+
     await Bun.write(SNAPSHOT_PATH, JSON.stringify(snapshot, null, 2))
-    await Bun.write(PROJECTS_LOG, "")
-    await Bun.write(CHATS_LOG, "")
-    await Bun.write(MESSAGES_LOG, "")
-    await Bun.write(TURNS_LOG, "")
+    await Promise.all([
+      Bun.write(PROJECTS_LOG, ""),
+      Bun.write(CHATS_LOG, ""),
+      Bun.write(MESSAGES_LOG, ""),
+      Bun.write(TURNS_LOG, ""),
+    ])
   }
 
   private async shouldCompact() {
-    const files = [PROJECTS_LOG, CHATS_LOG, MESSAGES_LOG, TURNS_LOG]
-    let total = 0
-    for (const filePath of files) {
-      total += Bun.file(filePath).size
-    }
-    return total >= COMPACTION_THRESHOLD_BYTES
+    const sizes = await Promise.all([
+      Bun.file(PROJECTS_LOG).size,
+      Bun.file(CHATS_LOG).size,
+      Bun.file(MESSAGES_LOG).size,
+      Bun.file(TURNS_LOG).size,
+    ])
+    return sizes.reduce((total, size) => total + size, 0) >= COMPACTION_THRESHOLD_BYTES
   }
 }

package/src/server/events.ts

@@ -1,4 +1,4 @@
-import type { ProjectSummary, TranscriptEntry } from "../shared/types"
+import type { AgentProvider, ProjectSummary, TranscriptEntry } from "../shared/types"
 
 export interface ProjectRecord extends ProjectSummary {
   deletedAt?: number
@@ -11,8 +11,9 @@ export interface ChatRecord {
   createdAt: number
   updatedAt: number
   deletedAt?: number
+  provider: AgentProvider | null
   planMode: boolean
-  resumeSessionId: string | null
+  sessionToken: string | null
   lastMessageAt?: number
   lastTurnOutcome: "success" | "failed" | "cancelled" | null
 }
@@ -25,7 +26,7 @@ export interface StoreState {
 }
 
 export interface SnapshotFile {
-  v: 1
+  v: 2
   generatedAt: number
   projects: ProjectRecord[]
   chats: ChatRecord[]
@@ -33,14 +34,14 @@ export interface SnapshotFile {
 }
 
 export type ProjectEvent = {
-  v: 1
+  v: 2
   type: "project_opened"
   timestamp: number
   projectId: string
   localPath: string
   title: string
 } | {
-  v: 1
+  v: 2
   type: "project_removed"
   timestamp: number
   projectId: string
@@ -48,7 +49,7 @@ export type ProjectEvent = {
 
 export type ChatEvent =
   | {
-      v: 1
+      v: 2
       type: "chat_created"
       timestamp: number
       chatId: string
@@ -56,20 +57,27 @@ export type ChatEvent =
       title: string
     }
   | {
-      v: 1
+      v: 2
       type: "chat_renamed"
       timestamp: number
       chatId: string
       title: string
     }
   | {
-      v: 1
+      v: 2
       type: "chat_deleted"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
+      v: 2
+      type: "chat_provider_set"
+      timestamp: number
+      chatId: string
+      provider: AgentProvider
+    }
+  | {
+      v: 2
       type: "chat_plan_mode_set"
       timestamp: number
       chatId: string
@@ -77,7 +85,7 @@ export type ChatEvent =
     }
 
 export type MessageEvent = {
-  v: 1
+  v: 2
   type: "message_appended"
   timestamp: number
   chatId: string
@@ -86,36 +94,36 @@ export type MessageEvent = {
 
 export type TurnEvent =
   | {
-      v: 1
+      v: 2
       type: "turn_started"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
+      v: 2
       type: "turn_finished"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
+      v: 2
       type: "turn_failed"
       timestamp: number
       chatId: string
       error: string
     }
   | {
-      v: 1
+      v: 2
       type: "turn_cancelled"
       timestamp: number
       chatId: string
     }
   | {
-      v: 1
-      type: "resume_session_set"
+      v: 2
+      type: "session_token_set"
       timestamp: number
       chatId: string
-      sessionId: string | null
+      sessionToken: string | null
     }
 
 export type StoreEvent = ProjectEvent | ChatEvent | MessageEvent | TurnEvent

package/src/server/generate-title.ts

@@ -1,43 +1,36 @@
-import { query } from "@anthropic-ai/claude-agent-sdk"
+import { QuickResponseAdapter } from "./quick-response"
 
-export async function generateTitleForChat(messageContent: string): Promise<string | null> {
-  try {
-    const q = query({
-      prompt: `Generate a short, descriptive title (under 30 chars) for a conversation that starts with this message. Return JSON matching the schema.\n\n${messageContent}`,
-      options: {
-        model: "haiku",
-        tools: [],
-        systemPrompt: "",
-        effort: "low",
-        permissionMode: "bypassPermissions",
-        outputFormat: {
-          type: "json_schema",
-          schema: {
-            type: "object",
-            properties: {
-              title: { type: "string" },
-            },
-            required: ["title"],
-            additionalProperties: false,
-          },
-        },
-        env: { ...process.env },
-      },
-    })
+const TITLE_SCHEMA = {
+  type: "object",
+  properties: {
+    title: { type: "string" },
+  },
+  required: ["title"],
+  additionalProperties: false,
+} as const
 
-    try {
-      for await (const message of q) {
-        if ("result" in message) {
-          const output = (message as Record<string, unknown>).structured_output as { title?: string } | undefined
-          return typeof output?.title === "string" ? output.title.slice(0, 80) : null
-        }
-      }
-    } finally {
-      q.close()
-    }
+function normalizeGeneratedTitle(value: unknown): string | null {
+  if (typeof value !== "string") return null
+  const normalized = value.replace(/\s+/g, " ").trim().slice(0, 80)
+  if (!normalized || normalized === "New Chat") return null
+  return normalized
+}
+
+export async function generateTitleForChat(
+  messageContent: string,
+  cwd: string,
+  adapter = new QuickResponseAdapter()
+): Promise<string | null> {
+  const result = await adapter.generateStructured<string>({
+    cwd,
+    task: "conversation title generation",
+    prompt: `Generate a short, descriptive title (under 30 chars) for a conversation that starts with this message.\n\n${messageContent}`,
+    schema: TITLE_SCHEMA,
+    parse: (value) => {
+      const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+      return normalizeGeneratedTitle(output.title)
+    },
+  })
 
-    return null
-  } catch {
-    return null
-  }
+  return result
 }

package/src/server/harness-types.ts

@@ -0,0 +1,19 @@
+import type { AccountInfo, AgentProvider, NormalizedToolCall, TranscriptEntry } from "../shared/types"
+
+export interface HarnessEvent {
+  type: "transcript" | "session_token"
+  entry?: TranscriptEntry
+  sessionToken?: string
+}
+
+export interface HarnessToolRequest {
+  tool: NormalizedToolCall & { toolKind: "ask_user_question" | "exit_plan_mode" }
+}
+
+export interface HarnessTurn {
+  provider: AgentProvider
+  stream: AsyncIterable<HarnessEvent>
+  getAccountInfo?: () => Promise<AccountInfo | null>
+  interrupt: () => Promise<void>
+  close: () => void
+}

package/src/server/provider-catalog.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "bun:test"
+import {
+  codexServiceTierFromModelOptions,
+  normalizeClaudeModelOptions,
+  normalizeCodexModelOptions,
+} from "./provider-catalog"
+
+describe("provider catalog normalization", () => {
+  test("maps legacy Claude effort into shared model options", () => {
+    expect(normalizeClaudeModelOptions(undefined, "max")).toEqual({
+      reasoningEffort: "max",
+    })
+  })
+
+  test("normalizes Codex model options and fast mode defaults", () => {
+    expect(normalizeCodexModelOptions(undefined)).toEqual({
+      reasoningEffort: "high",
+      fastMode: false,
+    })
+
+    const normalized = normalizeCodexModelOptions({
+      codex: {
+        reasoningEffort: "xhigh",
+        fastMode: true,
+      },
+    })
+
+    expect(normalized).toEqual({
+      reasoningEffort: "xhigh",
+      fastMode: true,
+    })
+    expect(codexServiceTierFromModelOptions(normalized)).toBe("fast")
+  })
+})

package/src/server/provider-catalog.ts

@@ -0,0 +1,77 @@
+import type {
+  AgentProvider,
+  ClaudeModelOptions,
+  CodexModelOptions,
+  ModelOptions,
+  ProviderCatalogEntry,
+  ProviderModelOption,
+  ServiceTier,
+} from "../shared/types"
+import {
+  DEFAULT_CLAUDE_MODEL_OPTIONS,
+  DEFAULT_CODEX_MODEL_OPTIONS,
+  PROVIDERS,
+  isClaudeReasoningEffort,
+  isCodexReasoningEffort,
+} from "../shared/types"
+
+const HARD_CODED_CODEX_MODELS: ProviderModelOption[] = [
+  { id: "gpt-5.4", label: "GPT-5.4", supportsEffort: false },
+  { id: "gpt-5.3-codex", label: "GPT-5.3 Codex", supportsEffort: false },
+  { id: "gpt-5.3-codex-spark", label: "GPT-5.3 Codex Spark", supportsEffort: false },
+]
+
+export const SERVER_PROVIDERS: ProviderCatalogEntry[] = PROVIDERS.map((provider) =>
+  provider.id === "codex"
+    ? {
+        ...provider,
+        defaultModel: "gpt-5.4",
+        models: HARD_CODED_CODEX_MODELS,
+      }
+    : provider
+)
+
+export function getServerProviderCatalog(provider: AgentProvider): ProviderCatalogEntry {
+  const entry = SERVER_PROVIDERS.find((candidate) => candidate.id === provider)
+  if (!entry) {
+    throw new Error(`Unknown provider: ${provider}`)
+  }
+  return entry
+}
+
+export function normalizeServerModel(provider: AgentProvider, model?: string): string {
+  const catalog = getServerProviderCatalog(provider)
+  if (model && catalog.models.some((candidate) => candidate.id === model)) {
+    return model
+  }
+  return catalog.defaultModel
+}
+
+export function normalizeClaudeModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): ClaudeModelOptions {
+  const reasoningEffort = modelOptions?.claude?.reasoningEffort
+  return {
+    reasoningEffort: isClaudeReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isClaudeReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CLAUDE_MODEL_OPTIONS.reasoningEffort,
+  }
+}
+
+export function normalizeCodexModelOptions(modelOptions?: ModelOptions, legacyEffort?: string): CodexModelOptions {
+  const reasoningEffort = modelOptions?.codex?.reasoningEffort
+  return {
+    reasoningEffort: isCodexReasoningEffort(reasoningEffort)
+      ? reasoningEffort
+      : isCodexReasoningEffort(legacyEffort)
+        ? legacyEffort
+        : DEFAULT_CODEX_MODEL_OPTIONS.reasoningEffort,
+    fastMode: typeof modelOptions?.codex?.fastMode === "boolean"
+      ? modelOptions.codex.fastMode
+      : DEFAULT_CODEX_MODEL_OPTIONS.fastMode,
+  }
+}
+
+export function codexServiceTierFromModelOptions(modelOptions: CodexModelOptions): ServiceTier | undefined {
+  return modelOptions.fastMode ? "fast" : undefined
+}

package/src/server/quick-response.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, test } from "bun:test"
+import { generateTitleForChat } from "./generate-title"
+import { QuickResponseAdapter } from "./quick-response"
+
+describe("QuickResponseAdapter", () => {
+  test("returns the Claude structured result when it validates", async () => {
+    const adapter = new QuickResponseAdapter({
+      runClaudeStructured: async () => ({ title: "Claude title" }),
+      runCodexStructured: async () => ({ title: "Codex title" }),
+    })
+
+    const result = await adapter.generateStructured({
+      cwd: "/tmp/project",
+      task: "title generation",
+      prompt: "Generate a title",
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+        },
+        required: ["title"],
+        additionalProperties: false,
+      },
+      parse: (value) => {
+        const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+        return typeof output.title === "string" ? output.title : null
+      },
+    })
+
+    expect(result).toBe("Claude title")
+  })
+
+  test("falls back to Codex when Claude fails validation", async () => {
+    const adapter = new QuickResponseAdapter({
+      runClaudeStructured: async () => ({ bad: true }),
+      runCodexStructured: async () => ({ title: "Codex title" }),
+    })
+
+    const result = await adapter.generateStructured({
+      cwd: "/tmp/project",
+      task: "title generation",
+      prompt: "Generate a title",
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+        },
+        required: ["title"],
+        additionalProperties: false,
+      },
+      parse: (value) => {
+        const output = value && typeof value === "object" ? value as { title?: unknown } : {}
+        return typeof output.title === "string" ? output.title : null
+      },
+    })
+
+    expect(result).toBe("Codex title")
+  })
+})
+
+describe("generateTitleForChat", () => {
+  test("sanitizes generated titles", async () => {
+    const title = await generateTitleForChat(
+      "hello",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => ({ title: "   Example\nTitle   " }),
+      })
+    )
+
+    expect(title).toBe("Example Title")
+  })
+
+  test("rejects invalid generated titles", async () => {
+    const title = await generateTitleForChat(
+      "hello",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => ({ title: "   " }),
+        runCodexStructured: async () => ({ title: "New Chat" }),
+      })
+    )
+
+    expect(title).toBeNull()
+  })
+})