kanna-code 0.1.4 → 0.3.0

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,
+      },
+    ])
+  })
+})

package/src/server/discovery.ts

@@ -1,6 +1,10 @@
-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"
+
+const LOG_PREFIX = "[kanna discovery]"
 
 export interface DiscoveredProject {
   localPath: string
@@ -8,6 +12,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 +51,290 @@ 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)) {
+      console.log(`${LOG_PREFIX} provider=claude status=missing root=${projectsDir}`)
+      return []
+    }
+
+    const entries = readdirSync(projectsDir, { withFileTypes: true })
+    const projects: ProviderDiscoveredProject[] = []
+    let directoryEntries = 0
+    let skippedMissing = 0
+
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue
+      directoryEntries += 1
+
+      const resolvedPath = resolveEncodedClaudePath(entry.name)
+      const normalizedPath = normalizeExistingDirectory(resolvedPath)
+      if (!normalizedPath) {
+        skippedMissing += 1
+        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,
+    }))
+
+    console.log(
+      `${LOG_PREFIX} provider=claude scanned=${directoryEntries} valid=${projects.length} deduped=${mergedProjects.length} skipped_missing=${skippedMissing} samples=${mergedProjects.slice(0, 5).map((project) => project.localPath).join(", ") || "-"}`
+    )
+
+    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[] = []
+    let skippedMissingMeta = 0
+    let skippedRelative = 0
+    let skippedMissingPath = 0
+    let fallbackSessionTimestamps = 0
+    let configProjectsIncluded = 0
+
+    if (!existsSync(indexPath) || !existsSync(sessionsDir) || !existsSync(configPath)) {
+      console.log(
+        `${LOG_PREFIX} provider=codex status=missing index_exists=${existsSync(indexPath)} sessions_exists=${existsSync(sessionsDir)} config_exists=${existsSync(configPath)}`
+      )
+    }
+
+    for (const [sessionId, metadata] of metadataById.entries()) {
+      const modifiedAt = updatedAtById.get(sessionId) ?? metadata.modifiedAt
+      const cwd = metadata.cwd
+      if (!updatedAtById.has(sessionId)) {
+        fallbackSessionTimestamps += 1
+      }
+      if (!cwd) {
+        skippedMissingMeta += 1
+        continue
+      }
+      if (!path.isAbsolute(cwd)) {
+        skippedRelative += 1
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(cwd)
+      if (!normalizedPath) {
+        skippedMissingPath += 1
+        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)) {
+        skippedRelative += 1
+        continue
+      }
+
+      const normalizedPath = normalizeExistingDirectory(configuredPath)
+      if (!normalizedPath) {
+        skippedMissingPath += 1
+        continue
+      }
+
+      configProjectsIncluded += 1
+      projects.push({
+        provider: this.provider,
+        localPath: normalizedPath,
+        title: path.basename(normalizedPath) || normalizedPath,
+        modifiedAt,
+      })
+    }
+
+    const mergedProjects = mergeDiscoveredProjects(projects).map((project) => ({
+      provider: this.provider,
+      ...project,
+    }))
+
+    console.log(
+      `${LOG_PREFIX} provider=codex indexed_sessions=${updatedAtById.size} session_meta=${metadataById.size} config_projects=${configuredProjects.size} valid=${projects.length} deduped=${mergedProjects.length} fallback_session_timestamps=${fallbackSessionTimestamps} config_projects_included=${configProjectsIncluded} skipped_missing_meta=${skippedMissingMeta} skipped_relative=${skippedRelative} skipped_missing_path=${skippedMissingPath} samples=${mergedProjects.slice(0, 5).map((project) => project.localPath).join(", ") || "-"}`
+    )
+
+    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))
+  )
+
+  console.log(
+    `${LOG_PREFIX} aggregate providers=${adapters.map((adapter) => adapter.provider).join(",")} total=${mergedProjects.length} samples=${mergedProjects.slice(0, 10).map((project) => project.localPath).join(", ") || "-"}`
+  )
+
+  return mergedProjects
 }