kanna-code 0.2.0 → 0.4.0

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") {
@@ -1136,6 +1186,104 @@ describe("CodexAppServerManager", () => {
     })
   })
 
+  test("infers multi-select Codex questions from prompt text and returns multiple answers", 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-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        child.writeServerMessage({
+          id: message.id,
+          result: { turn: { id: "turn-1", status: "inProgress", error: null } },
+        })
+        child.writeServerMessage({
+          id: "req-1",
+          method: "item/tool/requestUserInput",
+          params: {
+            threadId: "thread-1",
+            turnId: "turn-1",
+            itemId: "ask-1",
+            questions: [
+              {
+                id: "runtimes",
+                header: "Runtime",
+                question: "Select all runtimes that apply",
+                isOther: true,
+                isSecret: false,
+                options: [
+                  { label: "bun", description: null },
+                  { label: "node", description: null },
+                ],
+              },
+            ],
+          },
+        })
+        child.writeServerMessage({
+          method: "turn/completed",
+          params: {
+            threadId: "thread-1",
+            turn: { id: "turn-1", status: "completed", error: null },
+          },
+        })
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "ask me",
+      planMode: false,
+      onToolRequest: async ({ tool }) => {
+        expect(tool.toolKind).toBe("ask_user_question")
+        if (tool.toolKind !== "ask_user_question") {
+          return {}
+        }
+
+        expect(tool.input.questions[0]?.multiSelect).toBe(true)
+
+        return {
+          questions: [{
+            id: "runtimes",
+            question: "Select all runtimes that apply",
+            multiSelect: true,
+          }],
+          answers: {
+            runtimes: ["bun", "node"],
+          },
+        }
+      },
+    })
+
+    await collectStream(turn.stream)
+
+    const response = process.messages.find((message: any) => message.id === "req-1")
+    expect(response).toEqual({
+      id: "req-1",
+      result: {
+        answers: {
+          runtimes: {
+            answers: ["bun", "node"],
+          },
+        },
+      },
+    })
+  })
+
   test("sends approval decisions back to the app-server", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {
@@ -1257,6 +1405,94 @@ describe("CodexAppServerManager", () => {
     })
   })
 
+  test("interrupt clears a pending exit-plan wait so a new turn can start immediately", async () => {
+    let resolveToolRequest!: (value: unknown) => void
+
+    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-1" }, model: "gpt-5.4", reasoningEffort: "high" },
+        })
+      } else if (message.method === "turn/start") {
+        if (message.params.input[0]?.text === "make a plan") {
+          child.writeServerMessage({
+            id: message.id,
+            result: { turn: { id: "turn-plan", status: "completed", error: null } },
+          })
+          child.writeServerMessage({
+            method: "turn/plan/updated",
+            params: {
+              threadId: "thread-1",
+              turnId: "turn-plan",
+              explanation: "Plan the work",
+              plan: [{ step: "Inspect repo", status: "completed" }],
+            },
+          })
+          child.writeServerMessage({
+            method: "turn/completed",
+            params: {
+              threadId: "thread-1",
+              turn: { id: "turn-plan", status: "completed", error: null },
+            },
+          })
+        } else {
+          child.writeServerMessage({
+            id: message.id,
+            result: { turn: { id: "turn-next", status: "completed", error: null } },
+          })
+          child.writeServerMessage({
+            method: "turn/completed",
+            params: {
+              threadId: "thread-1",
+              turn: { id: "turn-next", status: "completed", error: null },
+            },
+          })
+        }
+      }
+    })
+
+    const manager = new CodexAppServerManager({
+      spawnProcess: () => process as never,
+    })
+
+    await manager.startSession({
+      chatId: "chat-1",
+      cwd: "/tmp/project",
+      model: "gpt-5.4",
+      sessionToken: null,
+    })
+
+    const turn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "make a plan",
+      planMode: true,
+      onToolRequest: async () => await new Promise((resolve) => {
+        resolveToolRequest = resolve
+      }),
+    })
+
+    const iterator = turn.stream[Symbol.asyncIterator]()
+    await iterator.next()
+    await iterator.next()
+    await iterator.next()
+    await turn.interrupt()
+
+    const nextTurn = await manager.startTurn({
+      chatId: "chat-1",
+      model: "gpt-5.4",
+      content: "continue",
+      planMode: false,
+      onToolRequest: async () => ({}),
+    })
+
+    await collectStream(nextTurn.stream)
+    resolveToolRequest({})
+  })
+
   test("emits an error result when the app-server exits mid-turn", async () => {
     const process = new FakeCodexProcess((message, child) => {
       if (message.method === "initialize") {

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

@@ -30,6 +30,7 @@ import {
   type ThreadStartParams,
   type ThreadStartResponse,
   type ToolRequestUserInputParams,
+  type ToolRequestUserInputQuestion,
   type ToolRequestUserInputResponse,
   type TurnPlanStep,
   type TurnPlanUpdatedNotification,
@@ -122,6 +123,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()
@@ -166,6 +175,13 @@ function isRecoverableResumeError(error: unknown): boolean {
   )
 }
 
+const MULTI_SELECT_HINT_PATTERN = /\b(all that apply|select all|choose all|pick all|select multiple|choose multiple|pick multiple|multiple selections?|multiple choice|more than one|one or more)\b/i
+
+function inferQuestionAllowsMultiple(question: ToolRequestUserInputQuestion): boolean {
+  const combinedText = [question.header, question.question].filter(Boolean).join(" ")
+  return MULTI_SELECT_HINT_PATTERN.test(combinedText)
+}
+
 function toAskUserQuestionItems(params: ToolRequestUserInputParams): AskUserQuestionItem[] {
   return params.questions.map((question) => ({
     id: question.id,
@@ -175,7 +191,7 @@ function toAskUserQuestionItems(params: ToolRequestUserInputParams): AskUserQues
       label: option.label,
       description: option.description ?? undefined,
     })),
-    multiSelect: false,
+    multiSelect: inferQuestionAllowsMultiple(question),
   }))
 }
 
@@ -774,7 +790,14 @@ export class CodexAppServerManager {
       stream: queue,
       interrupt: async () => {
         const pendingTurn = context.pendingTurn
-        if (!pendingTurn?.turnId || !context.sessionToken) return
+        if (!pendingTurn) return
+
+        context.pendingTurn = null
+        pendingTurn.resolved = true
+        pendingTurn.queue.finish()
+
+        if (!pendingTurn.turnId || !context.sessionToken) return
+
         await this.sendRequest(context, "turn/interrupt", {
           threadId: context.sessionToken,
           turnId: pendingTurn.turnId,
@@ -784,6 +807,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,
+      },
+    ])
+  })
+})