codeblog-app 1.6.4 → 2.0.0

package/src/scanner/continue-dev.ts

@@ -1,95 +0,0 @@
-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

@@ -1,299 +0,0 @@
-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 immutable mode first (works when Cursor has the DB locked)
-  try {
-    const uri = "file:" + encodeURI(dbPath) + "?immutable=1"
-    const db = new BunDatabase(uri)
-    try { return fn(db) } finally { db.close() }
-  } catch { /* fall through */ }
-  // Fallback to readonly
-  try {
-    const db = new BunDatabase(dbPath, { readonly: true })
-    try { return fn(db) } finally { db.close() }
-  } catch {
-    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

@@ -1,123 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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"

package/src/scanner/platform.ts

@@ -1,44 +0,0 @@
-import * as fs from "fs"
-import * as os from "os"
-import * as path from "path"
-
-export type Platform = "macos" | "windows" | "linux"
-
-export function getPlatform(): Platform {
-  switch (os.platform()) {
-    case "win32":
-      return "windows"
-    case "darwin":
-      return "macos"
-    default:
-      return "linux"
-  }
-}
-
-export function getHome(): string {
-  return os.homedir()
-}
-
-export function getAppDataDir(): string {
-  const platform = getPlatform()
-  if (platform === "windows") return process.env.APPDATA || path.join(getHome(), "AppData", "Roaming")
-  if (platform === "macos") return path.join(getHome(), "Library", "Application Support")
-  return process.env.XDG_CONFIG_HOME || path.join(getHome(), ".config")
-}
-
-export function getLocalAppDataDir(): string {
-  const platform = getPlatform()
-  if (platform === "windows") return process.env.LOCALAPPDATA || path.join(getHome(), "AppData", "Local")
-  if (platform === "macos") return path.join(getHome(), "Library", "Application Support")
-  return process.env.XDG_DATA_HOME || path.join(getHome(), ".local", "share")
-}
-
-export function resolvePaths(candidates: string[]): string[] {
-  return candidates.filter((p) => {
-    try {
-      return fs.existsSync(p)
-    } catch {
-      return false
-    }
-  })
-}

package/src/scanner/registry.ts

@@ -1,68 +0,0 @@
-import type { Scanner, Session, ParsedSession } from "./types"
-
-const scanners: Scanner[] = []
-
-export function registerScanner(scanner: Scanner): void {
-  scanners.push(scanner)
-}
-
-export function getScanners(): Scanner[] {
-  return [...scanners]
-}
-
-export function getScannerBySource(source: string): Scanner | undefined {
-  return scanners.find((s) => s.sourceType === source)
-}
-
-function safeScannerCall<T>(scannerName: string, method: string, fn: () => T, fallback: T): T {
-  try {
-    return fn()
-  } catch (err) {
-    console.error(`[codeblog] Scanner "${scannerName}" ${method} failed:`, err instanceof Error ? err.message : err)
-    return fallback
-  }
-}
-
-export function scanAll(limit = 20, source?: string): Session[] {
-  const all: Session[] = []
-  const targets = source ? scanners.filter((s) => s.sourceType === source) : scanners
-
-  for (const scanner of targets) {
-    const sessions = safeScannerCall(scanner.name, "scan", () => scanner.scan(limit), [])
-    all.push(...sessions)
-  }
-
-  all.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
-  return all.slice(0, limit)
-}
-
-export function parseSession(filePath: string, source: string, maxTurns?: number): ParsedSession | null {
-  const scanner = getScannerBySource(source)
-  if (!scanner) return null
-  return safeScannerCall(scanner.name, "parse", () => scanner.parse(filePath, maxTurns), null)
-}
-
-export function listScannerStatus(): Array<{
-  name: string
-  source: string
-  description: string
-  available: boolean
-  dirs: string[]
-  error?: string
-}> {
-  return scanners.map((s) => {
-    try {
-      const dirs = s.getSessionDirs()
-      return { name: s.name, source: s.sourceType, description: s.description, available: dirs.length > 0, dirs }
-    } catch (err) {
-      return {
-        name: s.name,
-        source: s.sourceType,
-        description: s.description,
-        available: false,
-        dirs: [],
-        error: err instanceof Error ? err.message : String(err),
-      }
-    }
-  })
-}