kanna-code 0.18.0 → 0.20.0

package/src/server/events.ts

@@ -11,6 +11,7 @@ export interface ChatRecord {
   createdAt: number
   updatedAt: number
   deletedAt?: number
+  unread: boolean
   provider: AgentProvider | null
   planMode: boolean
   sessionToken: string | null
@@ -82,6 +83,13 @@ export type ChatEvent =
       chatId: string
       planMode: boolean
     }
+  | {
+      v: 2
+      type: "chat_read_state_set"
+      timestamp: number
+      chatId: string
+      unread: boolean
+    }
 
 export type MessageEvent = {
   v: 2

package/src/server/generate-title.ts

@@ -16,12 +16,39 @@ function normalizeGeneratedTitle(value: unknown): string | null {
   return normalized
 }
 
+export function fallbackTitleFromMessage(messageContent: string): string | null {
+  const normalized = messageContent.replace(/\s+/g, " ").trim()
+  if (!normalized) return null
+  if (normalized.length <= 35) return normalized
+  return `${normalized.slice(0, 35)}...`
+}
+
+export interface GenerateChatTitleResult {
+  title: string | null
+  usedFallback: boolean
+  failureMessage: string | null
+}
+
+function summarizeFailures(failures: Array<{ provider: "claude" | "codex"; reason: string }>) {
+  if (failures.length === 0) return null
+  return failures.map((failure) => failure.reason).join("; ")
+}
+
 export async function generateTitleForChat(
   messageContent: string,
   cwd: string,
   adapter = new QuickResponseAdapter()
 ): Promise<string | null> {
-  const result = await adapter.generateStructured<string>({
+  const result = await generateTitleForChatDetailed(messageContent, cwd, adapter)
+  return result.title
+}
+
+export async function generateTitleForChatDetailed(
+  messageContent: string,
+  cwd: string,
+  adapter = new QuickResponseAdapter()
+): Promise<GenerateChatTitleResult> {
+  const result = await adapter.generateStructuredWithDiagnostics<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}`,
@@ -32,5 +59,18 @@ export async function generateTitleForChat(
     },
   })
 
-  return result
+  if (result.value) {
+    return {
+      title: result.value,
+      usedFallback: false,
+      failureMessage: null,
+    }
+  }
+
+  const fallbackTitle = fallbackTitleFromMessage(messageContent)
+  return {
+    title: fallbackTitle,
+    usedFallback: true,
+    failureMessage: summarizeFailures(result.failures),
+  }
 }

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from "bun:test"
-import { generateTitleForChat } from "./generate-title"
-import { QuickResponseAdapter } from "./quick-response"
+import { fallbackTitleFromMessage, generateTitleForChat, generateTitleForChatDetailed } from "./generate-title"
+import { getQuickResponseWorkspace, QuickResponseAdapter } from "./quick-response"
 
 describe("QuickResponseAdapter", () => {
   test("returns the Claude structured result when it validates", async () => {
@@ -85,6 +85,83 @@ describe("QuickResponseAdapter", () => {
 
     expect(result).toBe("Codex title")
   })
+
+  test("uses the Kanna app data root as the quick-response workspace", async () => {
+    const previousProfile = process.env.KANNA_RUNTIME_PROFILE
+    process.env.KANNA_RUNTIME_PROFILE = "dev"
+
+    try {
+      let claudeCwd = ""
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured: async (args) => {
+          claudeCwd = args.cwd
+          return { title: "Claude title" }
+        },
+      })
+
+      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(claudeCwd).toBe(getQuickResponseWorkspace(process.env))
+      expect(claudeCwd.endsWith("/.kanna-dev")).toBe(true)
+    } finally {
+      if (previousProfile === undefined) {
+        delete process.env.KANNA_RUNTIME_PROFILE
+      } else {
+        process.env.KANNA_RUNTIME_PROFILE = previousProfile
+      }
+    }
+  })
+
+  test("uses gpt-5.4-mini for Codex title generation fallback", async () => {
+    const requests: Array<{ cwd: string; prompt: string; model?: string }> = []
+    const adapter = new QuickResponseAdapter({
+      codexManager: {
+        async generateStructured(args: { cwd: string; prompt: string; model?: string }) {
+          requests.push(args)
+          return "{\"title\":\"Codex title\"}"
+        },
+      } as never,
+      runClaudeStructured: async () => null,
+    })
+
+    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")
+    expect(requests).toHaveLength(1)
+    expect(requests[0]?.model).toBe("gpt-5.4-mini")
+  })
 })
 
 describe("generateTitleForChat", () => {
@@ -110,6 +187,52 @@ describe("generateTitleForChat", () => {
       })
     )
 
-    expect(title).toBeNull()
+    expect(title).toBe("hello")
+  })
+
+  test("falls back to the first 35 characters of the message with ellipsis", async () => {
+    const title = await generateTitleForChat(
+      "This message is definitely longer than thirty five characters",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Not authenticated")
+        },
+        runCodexStructured: async () => null,
+      })
+    )
+
+    expect(title).toBe("This message is definitely longer t...")
+  })
+
+  test("returns fallback metadata when providers fail", async () => {
+    const result = await generateTitleForChatDetailed(
+      "hello there",
+      "/tmp/project",
+      new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Not authenticated")
+        },
+        runCodexStructured: async () => {
+          throw new Error("Codex unavailable")
+        },
+      })
+    )
+
+    expect(result).toEqual({
+      title: "hello there",
+      usedFallback: true,
+      failureMessage: "claude failed conversation title generation: Not authenticated; codex failed conversation title generation: Codex unavailable",
+    })
+  })
+})
+
+describe("fallbackTitleFromMessage", () => {
+  test("normalizes whitespace", () => {
+    expect(fallbackTitleFromMessage("  hello\n   world  ")).toBe("hello world")
+  })
+
+  test("returns null for blank input", () => {
+    expect(fallbackTitleFromMessage("   \n  ")).toBeNull()
   })
 })

package/src/server/quick-response.ts

@@ -1,4 +1,6 @@
 import { query } from "@anthropic-ai/claude-agent-sdk"
+import { homedir } from "node:os"
+import { getDataRootDir } from "../shared/branding"
 import { CodexAppServerManager } from "./codex-app-server"
 
 const CLAUDE_STRUCTURED_TIMEOUT_MS = 5_000
@@ -24,6 +26,20 @@ interface QuickResponseAdapterArgs {
   runCodexStructured?: (args: Omit<StructuredQuickResponseArgs<unknown>, "parse">) => Promise<unknown | null>
 }
 
+export interface StructuredQuickResponseFailure {
+  provider: "claude" | "codex"
+  reason: string
+}
+
+export interface StructuredQuickResponseResult<T> {
+  value: T | null
+  failures: StructuredQuickResponseFailure[]
+}
+
+export function getQuickResponseWorkspace(env: Record<string, string | undefined> = process.env) {
+  return getDataRootDir(homedir(), env)
+}
+
 function parseJsonText(value: string): unknown | null {
   const trimmed = value.trim()
   if (!trimmed) return null
@@ -45,10 +61,35 @@ function parseJsonText(value: string): unknown | null {
   return null
 }
 
-async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknown>, "parse">): Promise<unknown | null> {
+function structuredOutputFromSdkMessage(message: unknown): unknown | null {
+  if (!message || typeof message !== "object") return null
+
+  const record = message as Record<string, unknown>
+  if (record.type === "result") {
+    return record.structured_output ?? null
+  }
+
+  const assistantMessage = record.message
+  if (!assistantMessage || typeof assistantMessage !== "object") return null
+  const content = (assistantMessage as { content?: unknown }).content
+  if (!Array.isArray(content)) return null
+
+  for (const item of content) {
+    if (!item || typeof item !== "object") continue
+    const toolUse = item as Record<string, unknown>
+    if (toolUse.type === "tool_use" && toolUse.name === "StructuredOutput") {
+      return toolUse.input ?? null
+    }
+  }
+
+  return null
+}
+
+export async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknown>, "parse">): Promise<unknown | null> {
   const q = query({
     prompt: args.prompt,
     options: {
+      cwd: args.cwd,
       model: "haiku",
       tools: [],
       systemPrompt: "",
@@ -66,8 +107,9 @@ async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknow
     const result = await Promise.race<unknown | null>([
       (async () => {
         for await (const message of q) {
-          if ("result" in message) {
-            return (message as Record<string, unknown>).structured_output ?? null
+          const structuredOutput = structuredOutputFromSdkMessage(message)
+          if (structuredOutput !== null) {
+            return structuredOutput
           }
         }
         return null
@@ -91,12 +133,13 @@ async function runClaudeStructured(args: Omit<StructuredQuickResponseArgs<unknow
   }
 }
 
-async function runCodexStructured(
+export async function runCodexStructured(
   codexManager: CodexAppServerManager,
   args: Omit<StructuredQuickResponseArgs<unknown>, "parse">
 ): Promise<unknown | null> {
   const response = await codexManager.generateStructured({
     cwd: args.cwd,
+    model: "gpt-5.4-mini",
     prompt: `${args.prompt}\n\nReturn JSON only that matches this schema:\n${JSON.stringify(args.schema, null, 2)}`,
   })
   if (typeof response !== "string") return null
@@ -115,17 +158,45 @@ export class QuickResponseAdapter {
       runCodexStructured(this.codexManager, structuredArgs))
   }
   async generateStructured<T>(args: StructuredQuickResponseArgs<T>): Promise<T | null> {
+    const result = await this.generateStructuredWithDiagnostics(args)
+    return result.value
+  }
+
+  async generateStructuredWithDiagnostics<T>(args: StructuredQuickResponseArgs<T>): Promise<StructuredQuickResponseResult<T>> {
     const request = {
-      cwd: args.cwd,
+      cwd: getQuickResponseWorkspace(),
       task: args.task,
       prompt: args.prompt,
       schema: args.schema,
     }
 
+    const failures: StructuredQuickResponseFailure[] = []
     const claudeResult = await this.tryProvider("claude", args.task, args.parse, () => this.runClaudeStructured(request))
-    if (claudeResult !== null) return claudeResult
+    if (claudeResult.value !== null) {
+      return {
+        value: claudeResult.value,
+        failures,
+      }
+    }
+    if (claudeResult.failure) {
+      failures.push(claudeResult.failure)
+    }
+
+    const codexResult = await this.tryProvider("codex", args.task, args.parse, () => this.runCodexStructured(request))
+    if (codexResult.value !== null) {
+      return {
+        value: codexResult.value,
+        failures,
+      }
+    }
+    if (codexResult.failure) {
+      failures.push(codexResult.failure)
+    }
 
-    return await this.tryProvider("codex", args.task, args.parse, () => this.runCodexStructured(request))
+    return {
+      value: null,
+      failures,
+    }
   }
 
   private async tryProvider<T>(
@@ -133,21 +204,43 @@ export class QuickResponseAdapter {
     task: string,
     parse: (value: unknown) => T | null,
     run: () => Promise<unknown | null>
-  ): Promise<T | null> {
+  ): Promise<{ value: T | null; failure: StructuredQuickResponseFailure | null }> {
     try {
       const result = await run()
       if (result === null) {
-        return null
+        return {
+          value: null,
+          failure: {
+            provider,
+            reason: `${provider} returned no result for ${task}`,
+          },
+        }
       }
-  
+
       const parsed = parse(result)
       if (parsed === null) {
-        return null
+        return {
+          value: null,
+          failure: {
+            provider,
+            reason: `${provider} returned invalid structured output for ${task}`,
+          },
+        }
+      }
+
+      return {
+        value: parsed,
+        failure: null,
       }
-  
-      return parsed
     } catch (error) {
-      return null
+      const message = error instanceof Error ? error.message : String(error)
+      return {
+        value: null,
+        failure: {
+          provider,
+          reason: `${provider} failed ${task}: ${message}`,
+        },
+      }
     }
   }
 }

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

@@ -19,6 +19,7 @@ describe("read models", () => {
       title: "Chat",
       createdAt: 1,
       updatedAt: 1,
+      unread: true,
       provider: "codex",
       planMode: false,
       sessionToken: "thread-1",
@@ -27,6 +28,7 @@ describe("read models", () => {
 
     const sidebar = deriveSidebarData(state, new Map())
     expect(sidebar.projectGroups[0]?.chats[0]?.provider).toBe("codex")
+    expect(sidebar.projectGroups[0]?.chats[0]?.unread).toBe(true)
   })
 
   test("includes available providers in chat snapshots", () => {
@@ -45,13 +47,14 @@ describe("read models", () => {
       title: "Chat",
       createdAt: 1,
       updatedAt: 1,
+      unread: false,
       provider: "claude",
       planMode: true,
       sessionToken: "session-1",
       lastTurnOutcome: null,
     })
 
-    const chat = deriveChatSnapshot(state, new Map(), "chat-1", () => [])
+    const chat = deriveChatSnapshot(state, new Map(), new Set(), "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([
@@ -77,6 +80,7 @@ describe("read models", () => {
       title: "Chat",
       createdAt: 1,
       updatedAt: 75,
+      unread: false,
       provider: "codex",
       planMode: false,
       sessionToken: null,

package/src/server/read-models.ts

@@ -35,6 +35,7 @@ export function deriveSidebarData(
         chatId: chat.id,
         title: chat.title,
         status: deriveStatus(chat, activeStatuses.get(chat.id)),
+        unread: chat.unread,
         localPath: project.localPath,
         provider: chat.provider,
         lastMessageAt: chat.lastMessageAt,
@@ -97,6 +98,7 @@ export function deriveLocalProjectsSnapshot(
 export function deriveChatSnapshot(
   state: StoreState,
   activeStatuses: Map<string, KannaStatus>,
+  drainingChatIds: Set<string>,
   chatId: string,
   getMessages: (chatId: string) => ChatSnapshot["messages"]
 ): ChatSnapshot | null {
@@ -111,6 +113,7 @@ export function deriveChatSnapshot(
     localPath: project.localPath,
     title: chat.title,
     status: deriveStatus(chat, activeStatuses.get(chat.id)),
+    isDraining: drainingChatIds.has(chat.id),
     provider: chat.provider,
     planMode: chat.planMode,
     sessionToken: chat.sessionToken,

package/src/server/title-generation.live.test.ts

@@ -0,0 +1,44 @@
+import { describe, expect, test } from "bun:test"
+import { CodexAppServerManager } from "./codex-app-server"
+import { fallbackTitleFromMessage, generateTitleForChatDetailed } from "./generate-title"
+import { QuickResponseAdapter, runClaudeStructured, runCodexStructured } from "./quick-response"
+
+const shouldRunLiveTests = process.env.KANNA_RUN_LIVE_TITLE_TESTS === "1"
+const LIVE_MESSAGE = "Please help me debug a websocket reconnection issue in a Bun server app"
+
+if (shouldRunLiveTests) {
+  describe("live title generation", () => {
+    test("generates a title with Claude", async () => {
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured,
+        runCodexStructured: async () => {
+          throw new Error("Codex fallback should not be used in the Claude live title test")
+        },
+      })
+
+      const result = await generateTitleForChatDetailed(LIVE_MESSAGE, process.cwd(), adapter)
+
+      expect(result.usedFallback).toBe(false)
+      expect(result.failureMessage).toBeNull()
+      expect(typeof result.title).toBe("string")
+      expect(result.title).not.toBe(fallbackTitleFromMessage(LIVE_MESSAGE))
+    }, 15_000)
+
+    test("generates a title with Codex", async () => {
+      const codexManager = new CodexAppServerManager()
+      const adapter = new QuickResponseAdapter({
+        runClaudeStructured: async () => {
+          throw new Error("Claude should not be used in the Codex live title test")
+        },
+        runCodexStructured: async (args) => runCodexStructured(codexManager, args),
+      })
+
+      const result = await generateTitleForChatDetailed(LIVE_MESSAGE, process.cwd(), adapter)
+
+      expect(result.usedFallback).toBe(false)
+      expect(result.failureMessage).toBeNull()
+      expect(typeof result.title).toBe("string")
+      expect(result.title).not.toBe(fallbackTitleFromMessage(LIVE_MESSAGE))
+    }, 15_000)
+  })
+}