kanna-code 0.2.0 → 0.3.0

package/src/server/agent.test.ts

@@ -64,6 +64,132 @@ describe("normalizeClaudeStreamMessage", () => {
 })
 
 describe("AgentCoordinator codex integration", () => {
+  test("generates a chat title in the background on the first user message", async () => {
+    const fakeCodexManager = {
+      async startSession() {},
+      async startTurn(): Promise<HarnessTurn> {
+        async function* stream() {
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "system_init",
+              provider: "codex",
+              model: "gpt-5.4",
+              tools: [],
+              agents: [],
+              slashCommands: [],
+              mcpServers: [],
+            }),
+          }
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "result",
+              subtype: "success",
+              isError: false,
+              durationMs: 0,
+              result: "",
+            }),
+          }
+        }
+
+        return {
+          provider: "codex",
+          stream: stream(),
+          interrupt: async () => {},
+          close: () => {},
+        }
+      },
+    }
+
+    const store = createFakeStore()
+    const coordinator = new AgentCoordinator({
+      store: store as never,
+      onStateChange: () => {},
+      codexManager: fakeCodexManager as never,
+      generateTitle: async () => "Generated title",
+    })
+
+    await coordinator.send({
+      type: "chat.send",
+      chatId: "chat-1",
+      provider: "codex",
+      content: "first message",
+      model: "gpt-5.4",
+    })
+
+    await waitFor(() => store.chat.title === "Generated title")
+    expect(store.messages[0]?.kind).toBe("user_prompt")
+  })
+
+  test("does not overwrite a manual rename when background title generation finishes later", async () => {
+    let releaseTitle!: () => void
+    const titleGate = new Promise<void>((resolve) => {
+      releaseTitle = resolve
+    })
+    const fakeCodexManager = {
+      async startSession() {},
+      async startTurn(): Promise<HarnessTurn> {
+        async function* stream() {
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "system_init",
+              provider: "codex",
+              model: "gpt-5.4",
+              tools: [],
+              agents: [],
+              slashCommands: [],
+              mcpServers: [],
+            }),
+          }
+          yield {
+            type: "transcript" as const,
+            entry: timestamped({
+              kind: "result",
+              subtype: "success",
+              isError: false,
+              durationMs: 0,
+              result: "",
+            }),
+          }
+        }
+
+        return {
+          provider: "codex",
+          stream: stream(),
+          interrupt: async () => {},
+          close: () => {},
+        }
+      },
+    }
+
+    const store = createFakeStore()
+    const coordinator = new AgentCoordinator({
+      store: store as never,
+      onStateChange: () => {},
+      codexManager: fakeCodexManager as never,
+      generateTitle: async () => {
+        await titleGate
+        return "Generated title"
+      },
+    })
+
+    await coordinator.send({
+      type: "chat.send",
+      chatId: "chat-1",
+      provider: "codex",
+      content: "first message",
+      model: "gpt-5.4",
+    })
+
+    await store.renameChat("chat-1", "Manual title")
+    releaseTitle()
+    await waitFor(() => store.turnFinishedCount === 1)
+
+    expect(store.chat.title).toBe("Manual title")
+  })
+
   test("binds codex provider and reuses the session token on later turns", async () => {
     const sessionCalls: Array<{ chatId: string; sessionToken: string | null }> = []
     const fakeCodexManager = {
@@ -383,7 +509,7 @@ function createFakeStore() {
       return project
     },
     getMessages() {
-      return [] as TranscriptEntry[]
+      return this.messages
     },
     async setChatProvider(_chatId: string, provider: "claude" | "codex") {
       chat.provider = provider

package/src/server/agent.ts

@@ -10,6 +10,7 @@ import { normalizeToolCall } from "../shared/tools"
 import type { ClientCommand } from "../shared/protocol"
 import { EventStore } from "./event-store"
 import { CodexAppServerManager } from "./codex-app-server"
+import { generateTitleForChat } from "./generate-title"
 import type { HarnessEvent, HarnessToolRequest, HarnessTurn } from "./harness-types"
 import {
   codexServiceTierFromModelOptions,
@@ -64,11 +65,7 @@ interface AgentCoordinatorArgs {
   store: EventStore
   onStateChange: () => void
   codexManager?: CodexAppServerManager
-}
-
-function deriveChatTitle(content: string) {
-  const singleLine = content.replace(/\s+/g, " ").trim()
-  return singleLine.slice(0, 60) || "New Chat"
+  generateTitle?: (messageContent: string, cwd: string) => Promise<string | null>
 }
 
 function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
@@ -321,12 +318,14 @@ export class AgentCoordinator {
   private readonly store: EventStore
   private readonly onStateChange: () => void
   private readonly codexManager: CodexAppServerManager
+  private readonly generateTitle: (messageContent: string, cwd: string) => Promise<string | null>
   readonly activeTurns = new Map<string, ActiveTurn>()
 
   constructor(args: AgentCoordinatorArgs) {
     this.store = args.store
     this.onStateChange = args.onStateChange
     this.codexManager = args.codexManager ?? new CodexAppServerManager()
+    this.generateTitle = args.generateTitle ?? generateTitleForChat
   }
 
   getActiveStatuses() {
@@ -390,9 +389,7 @@ export class AgentCoordinator {
     await this.store.setPlanMode(args.chatId, args.planMode)
 
     const existingMessages = this.store.getMessages(args.chatId)
-    if (args.appendUserPrompt && chat.title === "New Chat" && existingMessages.length === 0) {
-      await this.store.renameChat(args.chatId, deriveChatTitle(args.content))
-    }
+    const shouldGenerateTitle = args.appendUserPrompt && chat.title === "New Chat" && existingMessages.length === 0
 
     if (args.appendUserPrompt) {
       await this.store.appendMessage(args.chatId, timestamped({ kind: "user_prompt", content: args.content }, Date.now()))
@@ -404,6 +401,10 @@ export class AgentCoordinator {
       throw new Error("Project not found")
     }
 
+    if (shouldGenerateTitle) {
+      void this.generateTitleInBackground(args.chatId, args.content, project.localPath)
+    }
+
     const onToolRequest = async (request: HarnessToolRequest): Promise<unknown> => {
       const active = this.activeTurns.get(args.chatId)
       if (!active) {
@@ -511,6 +512,21 @@ export class AgentCoordinator {
     return { chatId }
   }
 
+  private async generateTitleInBackground(chatId: string, messageContent: string, cwd: string) {
+    try {
+      const title = await this.generateTitle(messageContent, cwd)
+      if (!title) return
+
+      const chat = this.store.requireChat(chatId)
+      if (chat.title !== "New Chat") return
+
+      await this.store.renameChat(chatId, title)
+      this.onStateChange()
+    } catch {
+      // Ignore background title generation failures.
+    }
+  }
+
   private async runTurn(active: ActiveTurn) {
     try {
       for await (const event of active.turn.stream) {

package/src/server/codex-app-server.test.ts

@@ -181,6 +181,56 @@ describe("CodexAppServerManager", () => {
     expect(turnStart?.params.collaborationMode?.settings?.reasoning_effort).toBeNull()
   })
 
+  test("generateStructured returns the final assistant JSON and stops the transient session", async () => {
+    const process = new FakeCodexProcess((message, child) => {
+      if (message.method === "initialize") {
+        child.writeServerMessage({ id: message.id, result: { userAgent: "codex-test" } })
+      } else if (message.method === "thread/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { thread: { id: "thread-structured" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { turn: { id: "turn-structured", status: "completed", error: null } },
+        })
+        child.writeServerMessage({
+          method: "item/completed",
+          params: {
+            threadId: "thread-structured",
+            turnId: "turn-structured",
+            item: {
+              type: "agentMessage",
+              id: "msg-structured",
+              text: "{\"title\":\"Codex title\"}",
+              phase: "final_answer",
+            },
+          },
+        })
+        child.writeServerMessage({
+          method: "turn/completed",
+          params: {
+            threadId: "thread-structured",
+            turn: { id: "turn-structured", status: "completed", error: null },
+          },
+        })
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    const result = await manager.generateStructured({
+      cwd: "/tmp/project",
+      prompt: "Return JSON",
+    })
+
+    expect(result).toBe("{\"title\":\"Codex title\"}")
+    expect(process.killed).toBe(true)
+  })
+
   test("maps command execution and agent output into the shared transcript stream", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

package/src/server/codex-app-server.ts

@@ -122,6 +122,14 @@ export interface StartCodexTurnArgs {
   onApprovalRequest?: PendingTurn["onApprovalRequest"]
 }
 
+export interface GenerateStructuredArgs {
+  cwd: string
+  prompt: string
+  model?: string
+  effort?: CodexReasoningEffort
+  serviceTier?: ServiceTier
+}
+
 function timestamped<T extends Omit<TranscriptEntry, "_id" | "createdAt">>(
   entry: T,
   createdAt = Date.now()
@@ -784,6 +792,49 @@ export class CodexAppServerManager {
     }
   }
 
+  async generateStructured(args: GenerateStructuredArgs): Promise<string | null> {
+    const chatId = `quick-${randomUUID()}`
+    let turn: HarnessTurn | null = null
+    let assistantText = ""
+    let resultText = ""
+
+    try {
+      await this.startSession({
+        chatId,
+        cwd: args.cwd,
+        model: args.model ?? "gpt-5.4",
+        serviceTier: args.serviceTier ?? "fast",
+        sessionToken: null,
+      })
+
+      turn = await this.startTurn({
+        chatId,
+        model: args.model ?? "gpt-5.4",
+        effort: args.effort,
+        serviceTier: args.serviceTier ?? "fast",
+        content: args.prompt,
+        planMode: false,
+        onToolRequest: async () => ({}),
+      })
+
+      for await (const event of turn.stream) {
+        if (event.type !== "transcript" || !event.entry) continue
+        if (event.entry.kind === "assistant_text") {
+          assistantText += assistantText ? `\n${event.entry.text}` : event.entry.text
+        }
+        if (event.entry.kind === "result" && !event.entry.isError && event.entry.result.trim()) {
+          resultText = event.entry.result
+        }
+      }
+
+      const candidate = assistantText.trim() || resultText.trim()
+      return candidate || null
+    } finally {
+      turn?.close()
+      this.stopSession(chatId)
+    }
+  }
+
   stopSession(chatId: string) {
     const context = this.sessions.get(chatId)
     if (!context) return

package/src/server/discovery.test.ts

@@ -0,0 +1,211 @@
+import { afterEach, describe, expect, test } from "bun:test"
+import { mkdtempSync, mkdirSync, rmSync, utimesSync, writeFileSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import {
+  ClaudeProjectDiscoveryAdapter,
+  CodexProjectDiscoveryAdapter,
+  discoverProjects,
+  type ProjectDiscoveryAdapter,
+} from "./discovery"
+
+const tempDirs: string[] = []
+
+function makeTempDir() {
+  const directory = mkdtempSync(path.join(tmpdir(), "kanna-discovery-"))
+  tempDirs.push(directory)
+  return directory
+}
+
+function encodeClaudeProjectPath(localPath: string) {
+  return `-${localPath.replace(/\//g, "-")}`
+}
+
+afterEach(() => {
+  for (const directory of tempDirs.splice(0)) {
+    rmSync(directory, { recursive: true, force: true })
+  }
+})
+
+describe("project discovery", () => {
+  test("Claude adapter decodes saved project paths", () => {
+    const homeDir = makeTempDir()
+    const projectDir = path.join(homeDir, "workspace", "alpha-project")
+    const claudeProjectsDir = path.join(homeDir, ".claude", "projects")
+    const projectMarkerDir = path.join(claudeProjectsDir, encodeClaudeProjectPath(projectDir))
+
+    mkdirSync(projectDir, { recursive: true })
+    mkdirSync(projectMarkerDir, { recursive: true })
+    utimesSync(projectMarkerDir, new Date("2026-03-16T10:00:00.000Z"), new Date("2026-03-16T10:00:00.000Z"))
+
+    const projects = new ClaudeProjectDiscoveryAdapter().scan(homeDir)
+
+    expect(projects).toEqual([
+      {
+        provider: "claude",
+        localPath: projectDir,
+        title: "alpha-project",
+        modifiedAt: new Date("2026-03-16T10:00:00.000Z").getTime(),
+      },
+    ])
+  })
+
+  test("Codex adapter reads cwd from session metadata and ignores stale or invalid entries", () => {
+    const homeDir = makeTempDir()
+    const sessionsDir = path.join(homeDir, ".codex", "sessions", "2026", "03", "16")
+    const liveProjectDir = path.join(homeDir, "workspace", "kanna")
+    const missingProjectDir = path.join(homeDir, "workspace", "missing-project")
+    mkdirSync(liveProjectDir, { recursive: true })
+    mkdirSync(sessionsDir, { recursive: true })
+
+    writeFileSync(path.join(homeDir, ".codex", "session_index.jsonl"), [
+      JSON.stringify({
+        id: "session-live",
+        updated_at: "2026-03-16T23:05:58.940134Z",
+      }),
+      JSON.stringify({
+        id: "session-missing",
+        updated_at: "2026-03-16T20:05:58.940134Z",
+      }),
+      JSON.stringify({
+        id: "session-relative",
+        updated_at: "2026-03-16T21:05:58.940134Z",
+      }),
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T23-05-52-session-live.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-16T23:05:52.000Z",
+        type: "session_meta",
+        payload: {
+          id: "session-live",
+          cwd: liveProjectDir,
+        },
+      }),
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T20-05-52-session-missing.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-16T20:05:52.000Z",
+        type: "session_meta",
+        payload: {
+          id: "session-missing",
+          cwd: missingProjectDir,
+        },
+      }),
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T21-05-52-session-relative.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-16T21:05:52.000Z",
+        type: "session_meta",
+        payload: {
+          id: "session-relative",
+          cwd: "./relative-path",
+        },
+      }),
+    ].join("\n"))
+
+    const projects = new CodexProjectDiscoveryAdapter().scan(homeDir)
+
+    expect(projects).toEqual([
+      {
+        provider: "codex",
+        localPath: liveProjectDir,
+        title: "kanna",
+        modifiedAt: Date.parse("2026-03-16T23:05:58.940134Z"),
+      },
+    ])
+  })
+
+  test("Codex adapter falls back to session timestamps and config projects when session index misses CLI entries", () => {
+    const homeDir = makeTempDir()
+    const sessionsDir = path.join(homeDir, ".codex", "sessions", "2026", "03", "16")
+    const cliProjectDir = path.join(homeDir, "workspace", "codex-test-2")
+    const configOnlyProjectDir = path.join(homeDir, "workspace", "config-only")
+    mkdirSync(cliProjectDir, { recursive: true })
+    mkdirSync(configOnlyProjectDir, { recursive: true })
+    mkdirSync(sessionsDir, { recursive: true })
+
+    writeFileSync(path.join(homeDir, ".codex", "session_index.jsonl"), "")
+    writeFileSync(path.join(homeDir, ".codex", "config.toml"), [
+      `personality = "pragmatic"`,
+      `[projects."${configOnlyProjectDir}"]`,
+      `trust_level = "trusted"`,
+    ].join("\n"))
+
+    writeFileSync(path.join(sessionsDir, "rollout-2026-03-16T23-42-24-cli-session.jsonl"), [
+      JSON.stringify({
+        timestamp: "2026-03-17T03:42:25.751Z",
+        type: "session_meta",
+        payload: {
+          id: "cli-session",
+          timestamp: "2026-03-17T03:42:24.578Z",
+          cwd: cliProjectDir,
+          originator: "codex-tui",
+          source: "cli",
+        },
+      }),
+    ].join("\n"))
+
+    const projects = new CodexProjectDiscoveryAdapter().scan(homeDir)
+
+    expect(projects.map((project) => project.localPath).sort()).toEqual([
+      cliProjectDir,
+      configOnlyProjectDir,
+    ].sort())
+    expect(projects.find((project) => project.localPath === cliProjectDir)?.modifiedAt).toBe(
+      Date.parse("2026-03-17T03:42:25.751Z")
+    )
+  })
+
+  test("discoverProjects de-dupes provider results by normalized path and keeps the newest timestamp", () => {
+    const adapters: ProjectDiscoveryAdapter[] = [
+      {
+        provider: "claude",
+        scan() {
+          return [
+            {
+              provider: "claude",
+              localPath: "/tmp/project",
+              title: "Claude Project",
+              modifiedAt: 10,
+            },
+          ]
+        },
+      },
+      {
+        provider: "codex",
+        scan() {
+          return [
+            {
+              provider: "codex",
+              localPath: "/tmp/project",
+              title: "Codex Project",
+              modifiedAt: 20,
+            },
+            {
+              provider: "codex",
+              localPath: "/tmp/other-project",
+              title: "Other Project",
+              modifiedAt: 15,
+            },
+          ]
+        },
+      },
+    ]
+
+    expect(discoverProjects("/unused-home", adapters)).toEqual([
+      {
+        localPath: "/tmp/project",
+        title: "Codex Project",
+        modifiedAt: 20,
+      },
+      {
+        localPath: "/tmp/other-project",
+        title: "Other Project",
+        modifiedAt: 15,
+      },
+    ])
+  })
+})