kanna-code 0.2.0 → 0.4.0

package/src/server/discovery.ts

@@ -1,6 +1,8 @@
-import { existsSync, readdirSync, statSync } from "node:fs"
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs"
 import { homedir } from "node:os"
 import path from "node:path"
+import type { AgentProvider } from "../shared/types"
+import { resolveLocalPath } from "./paths"
 
 export interface DiscoveredProject {
   localPath: string
@@ -8,6 +10,15 @@ export interface DiscoveredProject {
   modifiedAt: number
 }
 
+export interface ProviderDiscoveredProject extends DiscoveredProject {
+  provider: AgentProvider
+}
+
+export interface ProjectDiscoveryAdapter {
+  provider: AgentProvider
+  scan(homeDir?: string): ProviderDiscoveredProject[]
+}
+
 function resolveEncodedClaudePath(folderName: string) {
   const segments = folderName.replace(/^-/, "").split("-").filter(Boolean)
   let currentPath = ""
@@ -38,28 +49,253 @@ function resolveEncodedClaudePath(folderName: string) {
   return currentPath || "/"
 }
 
-export function discoverClaudeProjects(homeDir: string = homedir()): DiscoveredProject[] {
-  const projectsDir = path.join(homeDir, ".claude", "projects")
-  if (!existsSync(projectsDir)) {
+function normalizeExistingDirectory(localPath: string) {
+  try {
+    const normalized = resolveLocalPath(localPath)
+    if (!statSync(normalized).isDirectory()) {
+      return null
+    }
+    return normalized
+  } catch {
+    return null
+  }
+}
+
+function mergeDiscoveredProjects(projects: Iterable<DiscoveredProject>): DiscoveredProject[] {
+  const merged = new Map<string, DiscoveredProject>()
+
+  for (const project of projects) {
+    const existing = merged.get(project.localPath)
+    if (!existing || project.modifiedAt > existing.modifiedAt) {
+      merged.set(project.localPath, {
+        localPath: project.localPath,
+        title: project.title || path.basename(project.localPath) || project.localPath,
+        modifiedAt: project.modifiedAt,
+      })
+      continue
+    }
+
+    if (!existing.title && project.title) {
+      existing.title = project.title
+    }
+  }
+
+  return [...merged.values()].sort((a, b) => b.modifiedAt - a.modifiedAt)
+}
+
+export class ClaudeProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
+  readonly provider = "claude" as const
+
+  scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
+    const projectsDir = path.join(homeDir, ".claude", "projects")
+    if (!existsSync(projectsDir)) {
+      return []
+    }
+
+    const entries = readdirSync(projectsDir, { withFileTypes: true })
+    const projects: ProviderDiscoveredProject[] = []
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+
+      const resolvedPath = resolveEncodedClaudePath(entry.name)
+      const normalizedPath = normalizeExistingDirectory(resolvedPath)
+      if (!normalizedPath) {
+        continue
+      }
+
+      const stat = statSync(path.join(projectsDir, entry.name))
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt: stat.mtimeMs,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    return mergedProjects
+  }
+}
+
+function parseJsonRecord(line: string): Record<string, unknown> | null {
+  try {
+    const parsed = JSON.parse(line)
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null
+    }
+    return parsed as Record<string, unknown>
+  } catch {
+    return null
+  }
+}
+
+function readCodexSessionIndex(indexPath: string) {
+  const updatedAtById = new Map<string, number>()
+  if (!existsSync(indexPath)) {
+    return updatedAtById
+  }
+
+  for (const line of readFileSync(indexPath, "utf8").split("\n")) {
+    if (!line.trim()) continue
+    const record = parseJsonRecord(line)
+    if (!record) continue
+
+    const id = typeof record.id === "string" ? record.id : null
+    const updatedAt = typeof record.updated_at === "string" ? Date.parse(record.updated_at) : Number.NaN
+    if (!id || Number.isNaN(updatedAt)) continue
+
+    const existing = updatedAtById.get(id)
+    if (existing === undefined || updatedAt > existing) {
+      updatedAtById.set(id, updatedAt)
+    }
+  }
+
+  return updatedAtById
+}
+
+function collectCodexSessionFiles(directory: string): string[] {
+  if (!existsSync(directory)) {
     return []
   }
 
-  const entries = readdirSync(projectsDir, { withFileTypes: true })
-  const projects: DiscoveredProject[] = []
+  const files: string[] = []
+  for (const entry of readdirSync(directory, { withFileTypes: true })) {
+    const fullPath = path.join(directory, entry.name)
+    if (entry.isDirectory()) {
+      files.push(...collectCodexSessionFiles(fullPath))
+      continue
+    }
+    if (entry.isFile() && entry.name.endsWith(".jsonl")) {
+      files.push(fullPath)
+    }
+  }
+  return files
+}
+
+function readCodexConfiguredProjects(configPath: string) {
+  const projects = new Map<string, number>()
+  if (!existsSync(configPath)) {
+    return projects
+  }
+
+  const configMtime = statSync(configPath).mtimeMs
+  for (const line of readFileSync(configPath, "utf8").split("\n")) {
+    const match = line.match(/^\[projects\."(.+)"\]$/)
+    if (!match?.[1]) continue
+    projects.set(match[1], configMtime)
+  }
+
+  return projects
+}
+
+function readCodexSessionMetadata(sessionsDir: string) {
+  const metadataById = new Map<string, { cwd: string; modifiedAt: number }>()
+
+  for (const sessionFile of collectCodexSessionFiles(sessionsDir)) {
+    const fileStat = statSync(sessionFile)
+    const firstLine = readFileSync(sessionFile, "utf8").split("\n", 1)[0]
+    if (!firstLine?.trim()) continue
+
+    const record = parseJsonRecord(firstLine)
+    if (!record || record.type !== "session_meta") continue
 
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue
+    const payload = record.payload
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) continue
 
-    const resolvedPath = resolveEncodedClaudePath(entry.name)
-    if (!existsSync(resolvedPath)) continue
+    const payloadRecord = payload as Record<string, unknown>
+    const sessionId = typeof payloadRecord.id === "string" ? payloadRecord.id : null
+    const cwd = typeof payloadRecord.cwd === "string" ? payloadRecord.cwd : null
+    if (!sessionId || !cwd) continue
 
-    const stat = statSync(path.join(projectsDir, entry.name))
-    projects.push({
-      localPath: resolvedPath,
-      title: path.basename(resolvedPath) || resolvedPath,
-      modifiedAt: stat.mtimeMs,
-    })
+    const recordTimestamp = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN
+    const payloadTimestamp = typeof payloadRecord.timestamp === "string" ? Date.parse(payloadRecord.timestamp) : Number.NaN
+    const modifiedAt = [recordTimestamp, payloadTimestamp, fileStat.mtimeMs].find((value) => !Number.isNaN(value)) ?? fileStat.mtimeMs
+
+    metadataById.set(sessionId, { cwd, modifiedAt })
   }
 
-  return projects.sort((a, b) => b.modifiedAt - a.modifiedAt)
+  return metadataById
+}
+
+export class CodexProjectDiscoveryAdapter implements ProjectDiscoveryAdapter {
+  readonly provider = "codex" as const
+
+  scan(homeDir: string = homedir()): ProviderDiscoveredProject[] {
+    const indexPath = path.join(homeDir, ".codex", "session_index.jsonl")
+    const sessionsDir = path.join(homeDir, ".codex", "sessions")
+    const configPath = path.join(homeDir, ".codex", "config.toml")
+    const updatedAtById = readCodexSessionIndex(indexPath)
+    const metadataById = readCodexSessionMetadata(sessionsDir)
+    const configuredProjects = readCodexConfiguredProjects(configPath)
+    const projects: ProviderDiscoveredProject[] = []
+
+    for (const [sessionId, metadata] of metadataById.entries()) {
+      const modifiedAt = updatedAtById.get(sessionId) ?? metadata.modifiedAt
+      const cwd = metadata.cwd
+      if (!cwd) {
+        continue
+      }
+      if (!path.isAbsolute(cwd)) {
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(cwd)
+      if (!normalizedPath) {
+        continue
+      }
+
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    for (const [configuredPath, modifiedAt] of configuredProjects.entries()) {
+      if (!path.isAbsolute(configuredPath)) {
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(configuredPath)
+      if (!normalizedPath) {
+        continue
+      }
+
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    return mergedProjects
+  }
+}
+
+export const DEFAULT_PROJECT_DISCOVERY_ADAPTERS: ProjectDiscoveryAdapter[] = [
+  new ClaudeProjectDiscoveryAdapter(),
+  new CodexProjectDiscoveryAdapter(),
+]
+
+export function discoverProjects(
+  homeDir: string = homedir(),
+  adapters: ProjectDiscoveryAdapter[] = DEFAULT_PROJECT_DISCOVERY_ADAPTERS
+): DiscoveredProject[] {
+  const mergedProjects = mergeDiscoveredProjects(
+    adapters.flatMap((adapter) => adapter.scan(homeDir).map(({ provider: _provider, ...project }) => project))
+  )
+
+  return mergedProjects
 }

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/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()
+  })
+})

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

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test"
-import { deriveChatSnapshot, deriveSidebarData } from "./read-models"
+import { deriveChatSnapshot, deriveLocalProjectsSnapshot, deriveSidebarData } from "./read-models"
 import { createEmptyState } from "./events"
 
 describe("read models", () => {
@@ -60,4 +60,46 @@ describe("read models", () => {
       "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/server.ts

@@ -2,23 +2,25 @@ 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"
 
 export interface StartKannaServerOptions {
   port?: number
+  strictPort?: boolean
 }
 
 export async function startKannaServer(options: StartKannaServerOptions = {}) {
   const port = options.port ?? 3210
+  const strictPort = options.strictPort ?? false
   const store = new EventStore()
   const machineDisplayName = getMachineDisplayName()
   await store.initialize()
   let discoveredProjects: DiscoveredProject[] = []
 
   async function refreshDiscovery() {
-    discoveredProjects = discoverClaudeProjects()
+    discoveredProjects = discoverProjects()
     return discoveredProjects
   }
 
@@ -83,7 +85,7 @@ export async function startKannaServer(options: StartKannaServerOptions = {}) {
     } catch (err: unknown) {
       const isAddrInUse =
         err instanceof Error && "code" in err && (err as NodeJS.ErrnoException).code === "EADDRINUSE"
-      if (!isAddrInUse || attempt === MAX_PORT_ATTEMPTS - 1) {
+      if (!isAddrInUse || strictPort || attempt === MAX_PORT_ATTEMPTS - 1) {
         throw err
       }
       console.log(`Port ${actualPort} is in use, trying ${actualPort + 1}...`)