codeblog-app 0.1.0

package/src/scanner/codex.ts

@@ -0,0 +1,127 @@
+import * as path from "path"
+import * as fs from "fs"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome } from "./platform"
+import { listFiles, safeStats, readJsonl, extractProjectDescription } from "./fs-utils"
+
+interface CodexLine {
+  timestamp?: string
+  type?: string
+  payload?: {
+    type?: string
+    role?: string
+    content?: Array<{ type?: string; text?: string }>
+    cwd?: string
+  }
+}
+
+export const codexScanner: Scanner = {
+  name: "Codex (OpenAI CLI)",
+  sourceType: "codex",
+  description: "OpenAI Codex CLI sessions (~/.codex/)",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const candidates = [path.join(home, ".codex", "sessions"), path.join(home, ".codex", "archived_sessions")]
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    for (const dir of this.getSessionDirs()) {
+      const files = listFiles(dir, [".jsonl"], true)
+      for (const filePath of files) {
+        const stats = safeStats(filePath)
+        if (!stats) continue
+        const lines = readJsonl<CodexLine>(filePath)
+        if (lines.length < 3) continue
+        const messageTurns = extractCodexTurns(lines)
+        const humanMsgs = messageTurns.filter((t) => t.role === "human")
+        const aiMsgs = messageTurns.filter((t) => t.role === "assistant")
+        const startLine = lines.find((l) => l.payload?.cwd)
+        const projectPath = startLine?.payload?.cwd || null
+        const project = projectPath ? path.basename(projectPath) : path.basename(dir)
+        const projectDescription = projectPath ? extractProjectDescription(projectPath) : null
+        const preview = humanMsgs[0]?.content.slice(0, 200) || "(codex session)"
+
+        sessions.push({
+          id: path.basename(filePath, ".jsonl"),
+          source: "codex",
+          project,
+          projectPath: projectPath || undefined,
+          projectDescription: projectDescription || undefined,
+          title: preview.slice(0, 80) || "Codex session",
+          messageCount: messageTurns.length,
+          humanMessages: humanMsgs.length,
+          aiMessages: aiMsgs.length,
+          preview,
+          filePath,
+          modifiedAt: stats.mtime,
+          sizeBytes: stats.size,
+        })
+      }
+    }
+    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+    return sessions.slice(0, limit)
+  },
+
+  parse(filePath: string, maxTurns?: number): ParsedSession | null {
+    const lines = readJsonl<CodexLine>(filePath)
+    if (lines.length === 0) return null
+    const stats = safeStats(filePath)
+    const allTurns = extractCodexTurns(lines)
+    const turns = maxTurns ? allTurns.slice(0, maxTurns) : allTurns
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    const startLine = lines.find((l) => l.payload?.cwd)
+    const projectPath = startLine?.payload?.cwd || undefined
+    const project = projectPath ? path.basename(projectPath) : path.basename(path.dirname(filePath))
+    const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined
+
+    return {
+      id: path.basename(filePath, ".jsonl"),
+      source: "codex",
+      project,
+      projectPath,
+      projectDescription,
+      title: humanMsgs[0]?.content.slice(0, 80) || "Codex session",
+      messageCount: turns.length,
+      humanMessages: humanMsgs.length,
+      aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath,
+      modifiedAt: stats?.mtime || new Date(),
+      sizeBytes: stats?.size || 0,
+      turns,
+    }
+  },
+}
+
+function extractCodexTurns(lines: CodexLine[]): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  for (const line of lines) {
+    if (!line.payload || line.payload.type !== "message") continue
+    const textParts = (line.payload.content || []).filter((c) => c.text).map((c) => c.text || "").filter(Boolean)
+    const content = textParts.join("\n").trim()
+    if (!content) continue
+    if (line.payload.role === "developer" || line.payload.role === "system") continue
+    if (
+      line.payload.role === "user" &&
+      (content.startsWith("# AGENTS.md") ||
+        content.startsWith("<environment_context>") ||
+        content.startsWith("<permissions") ||
+        content.startsWith("<app-context>") ||
+        content.startsWith("<collaboration_mode>"))
+    )
+      continue
+    turns.push({
+      role: line.payload.role === "user" ? "human" : "assistant",
+      content,
+      timestamp: line.timestamp ? new Date(line.timestamp) : undefined,
+    })
+  }
+  return turns
+}

package/src/scanner/continue-dev.ts

@@ -0,0 +1,95 @@
+import * as path from "path"
+import * as fs from "fs"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome, getPlatform } from "./platform"
+import { listFiles, safeReadJson, safeStats } from "./fs-utils"
+
+export const continueDevScanner: Scanner = {
+  name: "Continue.dev",
+  sourceType: "continue",
+  description: "Continue.dev AI coding assistant sessions",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const platform = getPlatform()
+    const candidates: string[] = [path.join(home, ".continue", "sessions")]
+    if (platform === "macos") {
+      candidates.push(path.join(home, "Library", "Application Support", "Continue", "sessions"))
+    } else if (platform === "windows") {
+      const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+      candidates.push(path.join(appData, "Continue", "sessions"))
+    } else {
+      candidates.push(path.join(home, ".config", "continue", "sessions"))
+    }
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    for (const dir of this.getSessionDirs()) {
+      for (const filePath of listFiles(dir, [".json"])) {
+        const stats = safeStats(filePath)
+        if (!stats || stats.size < 100) continue
+        const data = safeReadJson<Record<string, unknown>>(filePath)
+        if (!data) continue
+        const turns = extractContinueTurns(data)
+        if (turns.length < 2) continue
+        const humanMsgs = turns.filter((t) => t.role === "human")
+        const preview = humanMsgs[0]?.content.slice(0, 200) || "(continue session)"
+        sessions.push({
+          id: path.basename(filePath, ".json"), source: "continue",
+          project: (data.workspacePath as string) || path.basename(path.dirname(filePath)),
+          title: (data.title as string) || preview.slice(0, 80),
+          messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: turns.length - humanMsgs.length,
+          preview, filePath, modifiedAt: stats.mtime, sizeBytes: stats.size,
+        })
+      }
+    }
+    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+    return sessions.slice(0, limit)
+  },
+
+  parse(filePath: string, maxTurns?: number): ParsedSession | null {
+    const data = safeReadJson<Record<string, unknown>>(filePath)
+    if (!data) return null
+    const stats = safeStats(filePath)
+    const turns = extractContinueTurns(data, maxTurns)
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    return {
+      id: path.basename(filePath, ".json"), source: "continue",
+      project: (data.workspacePath as string) || path.basename(path.dirname(filePath)),
+      title: (data.title as string) || humanMsgs[0]?.content.slice(0, 80) || "Continue session",
+      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath, modifiedAt: stats?.mtime || new Date(), sizeBytes: stats?.size || 0, turns,
+    }
+  },
+}
+
+function extractContinueTurns(data: Record<string, unknown>, maxTurns?: number): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  for (const arr of [data.history, data.messages, data.steps]) {
+    if (!Array.isArray(arr)) continue
+    for (const msg of arr) {
+      if (maxTurns && turns.length >= maxTurns) break
+      if (!msg || typeof msg !== "object") continue
+      const m = msg as Record<string, unknown>
+      if (m.name === "UserInput" && typeof m.description === "string") {
+        turns.push({ role: "human", content: m.description }); continue
+      }
+      if (m.name === "DefaultModelEditCodeStep" || m.name === "ChatModelResponse") {
+        if (typeof m.description === "string") turns.push({ role: "assistant", content: m.description })
+        continue
+      }
+      const content = (m.content || m.text || m.message) as string | undefined
+      if (typeof content !== "string") continue
+      turns.push({ role: m.role === "user" ? "human" : "assistant", content })
+    }
+    if (turns.length > 0) return turns
+  }
+  return turns
+}

package/src/scanner/cursor.ts

@@ -0,0 +1,293 @@
+import * as path from "path"
+import * as fs from "fs"
+import { Database as BunDatabase } from "bun:sqlite"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome, getPlatform } from "./platform"
+import { listFiles, listDirs, safeReadFile, safeReadJson, safeStats, extractProjectDescription } from "./fs-utils"
+
+const VSCDB_SEP = "|"
+
+function makeVscdbPath(dbPath: string, composerId: string): string {
+  return `vscdb:${dbPath}${VSCDB_SEP}${composerId}`
+}
+
+function parseVscdbVirtualPath(virtualPath: string): { dbPath: string; composerId: string } | null {
+  const prefix = "vscdb:"
+  if (!virtualPath.startsWith(prefix)) return null
+  const rest = virtualPath.slice(prefix.length)
+  const sepIdx = rest.lastIndexOf(VSCDB_SEP)
+  if (sepIdx <= 0) return null
+  return { dbPath: rest.slice(0, sepIdx), composerId: rest.slice(sepIdx + 1) }
+}
+
+function withDb<T>(dbPath: string, fn: (db: BunDatabase) => T, fallback: T): T {
+  try {
+    const db = new BunDatabase(dbPath, { readonly: true })
+    try { return fn(db) } finally { db.close() }
+  } catch (err) {
+    console.error(`[codeblog] Cursor DB error:`, err instanceof Error ? err.message : err)
+    return fallback
+  }
+}
+
+function safeQueryDb<T>(db: BunDatabase, sql: string, params: unknown[] = []): T[] {
+  try {
+    return db.prepare(sql).all(...params) as T[]
+  } catch (err) {
+    console.error(`[codeblog] Cursor query error:`, err instanceof Error ? err.message : err)
+    return []
+  }
+}
+
+function getGlobalStoragePath(): string | null {
+  const home = getHome()
+  const platform = getPlatform()
+  let p: string
+  if (platform === "macos") {
+    p = path.join(home, "Library", "Application Support", "Cursor", "User", "globalStorage", "state.vscdb")
+  } else if (platform === "windows") {
+    const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+    p = path.join(appData, "Cursor", "User", "globalStorage", "state.vscdb")
+  } else {
+    p = path.join(home, ".config", "Cursor", "User", "globalStorage", "state.vscdb")
+  }
+  try { return fs.existsSync(p) ? p : null } catch { return null }
+}
+
+interface CursorChatSession {
+  version?: number
+  requests: Array<{ message: string; response?: string | unknown[] }>
+  sessionId?: string
+}
+
+interface CursorComposerData {
+  composerId?: string
+  name?: string
+  createdAt?: number
+  lastUpdatedAt?: number
+  fullConversationHeadersOnly?: Array<{ bubbleId: string; type: number }>
+}
+
+export const cursorScanner: Scanner = {
+  name: "Cursor",
+  sourceType: "cursor",
+  description: "Cursor AI IDE sessions (agent transcripts + chat sessions + composer)",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const platform = getPlatform()
+    const candidates: string[] = [path.join(home, ".cursor", "projects")]
+
+    if (platform === "macos") {
+      candidates.push(path.join(home, "Library", "Application Support", "Cursor", "User", "workspaceStorage"))
+    } else if (platform === "windows") {
+      const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+      candidates.push(path.join(appData, "Cursor", "User", "workspaceStorage"))
+    } else {
+      candidates.push(path.join(home, ".config", "Cursor", "User", "workspaceStorage"))
+    }
+
+    const globalDb = getGlobalStoragePath()
+    if (globalDb) candidates.push(path.dirname(globalDb))
+
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    const dirs = this.getSessionDirs()
+    const seenIds = new Set<string>()
+
+    for (const baseDir of dirs) {
+      if (baseDir.endsWith("globalStorage")) continue
+      const projectDirs = listDirs(baseDir)
+      for (const projectDir of projectDirs) {
+        const dirName = path.basename(projectDir)
+        let projectPath: string | undefined
+        const workspaceJson = safeReadJson<{ folder?: string }>(path.join(projectDir, "workspace.json"))
+        if (workspaceJson?.folder) {
+          try { projectPath = decodeURIComponent(new URL(workspaceJson.folder).pathname) } catch { /* */ }
+        }
+        const project = projectPath ? path.basename(projectPath) : dirName
+        const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined
+
+        // FORMAT 1: agent-transcripts
+        for (const filePath of listFiles(path.join(projectDir, "agent-transcripts"), [".txt"])) {
+          const stats = safeStats(filePath)
+          if (!stats) continue
+          const content = safeReadFile(filePath)
+          if (!content || content.length < 100) continue
+          const userQueries = content.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/g) || []
+          if (userQueries.length === 0) continue
+          const firstQuery = content.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/)
+          const preview = firstQuery ? firstQuery[1].trim().slice(0, 200) : content.slice(0, 200)
+          const id = path.basename(filePath, ".txt")
+          seenIds.add(id)
+          sessions.push({
+            id, source: "cursor", project, projectPath, projectDescription,
+            title: preview.slice(0, 80) || `Cursor session in ${project}`,
+            messageCount: userQueries.length * 2, humanMessages: userQueries.length, aiMessages: userQueries.length,
+            preview, filePath, modifiedAt: stats.mtime, sizeBytes: stats.size,
+          })
+        }
+
+        // FORMAT 2: chatSessions
+        for (const filePath of listFiles(path.join(projectDir, "chatSessions"), [".json"])) {
+          const stats = safeStats(filePath)
+          if (!stats || stats.size < 100) continue
+          const data = safeReadJson<CursorChatSession>(filePath)
+          if (!data || !Array.isArray(data.requests) || data.requests.length === 0) continue
+          const humanCount = data.requests.length
+          const firstMsg = data.requests[0]?.message || ""
+          const preview = (typeof firstMsg === "string" ? firstMsg : "").slice(0, 200)
+          const id = data.sessionId || path.basename(filePath, ".json")
+          seenIds.add(id)
+          sessions.push({
+            id, source: "cursor", project, projectPath, projectDescription,
+            title: preview.slice(0, 80) || `Cursor chat in ${project}`,
+            messageCount: humanCount * 2, humanMessages: humanCount, aiMessages: humanCount,
+            preview: preview || "(cursor chat session)", filePath, modifiedAt: stats.mtime, sizeBytes: stats.size,
+          })
+        }
+      }
+    }
+
+    // FORMAT 3: globalStorage state.vscdb
+    const globalDb = getGlobalStoragePath()
+    if (globalDb) {
+      withDb(globalDb, (db) => {
+        const rows = safeQueryDb<{ key: string; value: string }>(
+          db, "SELECT key, value FROM cursorDiskKV WHERE key LIKE 'composerData:%'",
+        )
+        for (const row of rows) {
+          try {
+            const data = JSON.parse(row.value) as CursorComposerData
+            const composerId = data.composerId || row.key.replace("composerData:", "")
+            if (seenIds.has(composerId)) continue
+            const bubbleHeaders = data.fullConversationHeadersOnly || []
+            if (bubbleHeaders.length === 0) continue
+            const humanCount = bubbleHeaders.filter((b) => b.type === 1).length
+            const aiCount = bubbleHeaders.filter((b) => b.type === 2).length
+            let preview = data.name || ""
+            if (!preview) {
+              const firstUserBubble = bubbleHeaders.find((b) => b.type === 1)
+              if (firstUserBubble) {
+                const bubbleRow = safeQueryDb<{ value: string }>(
+                  db, "SELECT value FROM cursorDiskKV WHERE key = ?",
+                  [`bubbleId:${composerId}:${firstUserBubble.bubbleId}`],
+                )
+                if (bubbleRow.length > 0) {
+                  try {
+                    const bubble = JSON.parse(bubbleRow[0].value)
+                    preview = (bubble.text || bubble.message || "").slice(0, 200)
+                  } catch { /* */ }
+                }
+              }
+            }
+            const createdAt = data.createdAt ? new Date(data.createdAt) : new Date()
+            const updatedAt = data.lastUpdatedAt ? new Date(data.lastUpdatedAt) : createdAt
+            sessions.push({
+              id: composerId, source: "cursor", project: "Cursor Composer",
+              title: (data.name || preview || "Cursor composer session").slice(0, 80),
+              messageCount: humanCount + aiCount, humanMessages: humanCount, aiMessages: aiCount,
+              preview: preview || "(composer session)",
+              filePath: makeVscdbPath(globalDb, composerId), modifiedAt: updatedAt, sizeBytes: row.value.length,
+            })
+          } catch { /* skip */ }
+        }
+      }, undefined)
+    }
+
+    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
+    return sessions.slice(0, limit)
+  },
+
+  parse(filePath: string, maxTurns?: number): ParsedSession | null {
+    if (filePath.startsWith("vscdb:")) return parseVscdbSession(filePath, maxTurns)
+    const stats = safeStats(filePath)
+    const turns: ConversationTurn[] = []
+
+    if (filePath.endsWith(".txt")) {
+      const content = safeReadFile(filePath)
+      if (!content) return null
+      const blocks = content.split(/^user:\s*$/m)
+      for (const block of blocks) {
+        if (!block.trim()) continue
+        if (maxTurns && turns.length >= maxTurns) break
+        const queryMatch = block.match(/<user_query>\n?([\s\S]*?)\n?<\/user_query>/)
+        if (queryMatch) turns.push({ role: "human", content: queryMatch[1].trim() })
+        const afterQuery = block.split(/<\/user_query>/)[1]
+        if (afterQuery) {
+          const aiContent = afterQuery.replace(/^\s*\n\s*A:\s*\n?/, "").trim()
+          if (aiContent && (!maxTurns || turns.length < maxTurns)) turns.push({ role: "assistant", content: aiContent })
+        }
+      }
+    } else {
+      const data = safeReadJson<CursorChatSession>(filePath)
+      if (!data || !Array.isArray(data.requests)) return null
+      for (const req of data.requests) {
+        if (maxTurns && turns.length >= maxTurns) break
+        if (req.message) turns.push({ role: "human", content: typeof req.message === "string" ? req.message : JSON.stringify(req.message) })
+        if (maxTurns && turns.length >= maxTurns) break
+        if (req.response) {
+          let respText = ""
+          if (typeof req.response === "string") respText = req.response
+          else if (Array.isArray(req.response)) {
+            respText = req.response.map((r: unknown) => (typeof r === "string" ? r : (r as Record<string, unknown>)?.text || "")).join("")
+          }
+          if (respText.trim()) turns.push({ role: "assistant", content: respText.trim() })
+        }
+      }
+    }
+
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    return {
+      id: path.basename(filePath).replace(/\.\w+$/, ""), source: "cursor",
+      project: path.basename(path.dirname(filePath)),
+      title: humanMsgs[0]?.content.slice(0, 80) || "Cursor session",
+      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath, modifiedAt: stats?.mtime || new Date(), sizeBytes: stats?.size || 0, turns,
+    }
+  },
+}
+
+function parseVscdbSession(virtualPath: string, maxTurns?: number): ParsedSession | null {
+  const parsed = parseVscdbVirtualPath(virtualPath)
+  if (!parsed) return null
+  return withDb(parsed.dbPath, (db) => {
+    const metaRows = safeQueryDb<{ value: string }>(db, "SELECT value FROM cursorDiskKV WHERE key = ?", [`composerData:${parsed.composerId}`])
+    if (metaRows.length === 0) return null
+    let composerData: CursorComposerData
+    try { composerData = JSON.parse(metaRows[0].value) } catch { return null }
+    const bubbleHeaders = composerData.fullConversationHeadersOnly || []
+    if (bubbleHeaders.length === 0) return null
+    const turns: ConversationTurn[] = []
+    for (const header of bubbleHeaders) {
+      if (maxTurns && turns.length >= maxTurns) break
+      const bubbleRows = safeQueryDb<{ value: string }>(db, "SELECT value FROM cursorDiskKV WHERE key = ?", [`bubbleId:${parsed.composerId}:${header.bubbleId}`])
+      if (bubbleRows.length === 0) continue
+      try {
+        const bubble = JSON.parse(bubbleRows[0].value)
+        const text = bubble.text || bubble.message || bubble.rawText || ""
+        if (!text && header.type === 2) { turns.push({ role: "assistant", content: "(AI response)" }); continue }
+        turns.push({ role: header.type === 1 ? "human" : "assistant", content: text || "(empty)" })
+      } catch { /* skip */ }
+    }
+    if (turns.length === 0) return null
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+    return {
+      id: parsed.composerId, source: "cursor" as const, project: "Cursor Composer",
+      title: composerData.name || humanMsgs[0]?.content.slice(0, 80) || "Cursor session",
+      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
+      preview: humanMsgs[0]?.content.slice(0, 200) || "",
+      filePath: virtualPath, modifiedAt: composerData.lastUpdatedAt ? new Date(composerData.lastUpdatedAt) : new Date(),
+      sizeBytes: 0, turns,
+    } as ParsedSession
+  }, null)
+}

package/src/scanner/fs-utils.ts

@@ -0,0 +1,123 @@
+import * as fs from "fs"
+import * as path from "path"
+
+export function safeReadFile(filePath: string): string | null {
+  try {
+    return fs.readFileSync(filePath, "utf-8")
+  } catch {
+    return null
+  }
+}
+
+export function safeReadJson<T = unknown>(filePath: string): T | null {
+  const content = safeReadFile(filePath)
+  if (!content) return null
+  try {
+    return JSON.parse(content) as T
+  } catch {
+    return null
+  }
+}
+
+export function safeStats(filePath: string): fs.Stats | null {
+  try {
+    return fs.statSync(filePath)
+  } catch {
+    return null
+  }
+}
+
+export function listFiles(dir: string, extensions?: string[], recursive = false): string[] {
+  if (!fs.existsSync(dir)) return []
+  const results: string[] = []
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+      if (entry.isFile()) {
+        if (!extensions || extensions.some((ext) => entry.name.endsWith(ext))) results.push(fullPath)
+      } else if (entry.isDirectory() && recursive) {
+        results.push(...listFiles(fullPath, extensions, true))
+      }
+    }
+  } catch {
+    // Permission denied or other errors
+  }
+  return results
+}
+
+export function listDirs(dir: string): string[] {
+  if (!fs.existsSync(dir)) return []
+  try {
+    return fs
+      .readdirSync(dir, { withFileTypes: true })
+      .filter((e) => e.isDirectory())
+      .map((e) => path.join(dir, e.name))
+  } catch {
+    return []
+  }
+}
+
+export function exists(p: string): boolean {
+  try {
+    return fs.existsSync(p)
+  } catch {
+    return false
+  }
+}
+
+export function extractProjectDescription(projectPath: string): string | null {
+  if (!projectPath || !fs.existsSync(projectPath)) return null
+
+  const pkgPath = path.join(projectPath, "package.json")
+  const pkg = safeReadJson<{ name?: string; description?: string }>(pkgPath)
+  if (pkg?.description) return pkg.description.slice(0, 200)
+
+  for (const readmeName of ["README.md", "readme.md", "Readme.md", "README.rst"]) {
+    const readmePath = path.join(projectPath, readmeName)
+    const content = safeReadFile(readmePath)
+    if (!content) continue
+    const lines = content.split("\n")
+    let desc = ""
+    for (const line of lines) {
+      const trimmed = line.trim()
+      if (!trimmed) {
+        if (desc) break
+        continue
+      }
+      if (trimmed.startsWith("#") || trimmed.startsWith("=") || trimmed.startsWith("-")) {
+        if (desc) break
+        continue
+      }
+      if (trimmed.startsWith("![") || trimmed.startsWith("<img")) continue
+      desc += (desc ? " " : "") + trimmed
+      if (desc.length > 200) break
+    }
+    if (desc.length > 10) return desc.slice(0, 300)
+  }
+
+  const cargoPath = path.join(projectPath, "Cargo.toml")
+  const cargo = safeReadFile(cargoPath)
+  if (cargo) {
+    const match = cargo.match(/description\s*=\s*"([^"]+)"/)
+    if (match) return match[1].slice(0, 200)
+  }
+
+  return null
+}
+
+export function readJsonl<T = unknown>(filePath: string): T[] {
+  const content = safeReadFile(filePath)
+  if (!content) return []
+  return content
+    .split("\n")
+    .filter(Boolean)
+    .map((line) => {
+      try {
+        return JSON.parse(line) as T
+      } catch {
+        return null
+      }
+    })
+    .filter((x): x is T => x !== null)
+}

package/src/scanner/index.ts

@@ -0,0 +1,26 @@
+import { registerScanner } from "./registry"
+import { claudeCodeScanner } from "./claude-code"
+import { cursorScanner } from "./cursor"
+import { windsurfScanner } from "./windsurf"
+import { codexScanner } from "./codex"
+import { warpScanner } from "./warp"
+import { vscodeCopilotScanner } from "./vscode-copilot"
+import { aiderScanner } from "./aider"
+import { continueDevScanner } from "./continue-dev"
+import { zedScanner } from "./zed"
+
+export function registerAllScanners(): void {
+  registerScanner(claudeCodeScanner)
+  registerScanner(cursorScanner)
+  registerScanner(windsurfScanner)
+  registerScanner(codexScanner)
+  registerScanner(warpScanner)
+  registerScanner(vscodeCopilotScanner)
+  registerScanner(aiderScanner)
+  registerScanner(continueDevScanner)
+  registerScanner(zedScanner)
+}
+
+export { scanAll, parseSession, listScannerStatus, getScanners } from "./registry"
+export { analyzeSession } from "./analyzer"
+export type { Session, ParsedSession, SessionAnalysis, Scanner, SourceType, ConversationTurn } from "./types"