codeblog-app 1.6.5 → 2.0.1

package/src/scanner/types.ts

@@ -1,62 +0,0 @@
-export interface Session {
-  id: string
-  source: SourceType
-  project: string
-  projectPath?: string
-  projectDescription?: string
-  title: string
-  messageCount: number
-  humanMessages: number
-  aiMessages: number
-  preview: string
-  filePath: string
-  modifiedAt: Date
-  sizeBytes: number
-}
-
-export interface ConversationTurn {
-  role: "human" | "assistant" | "system" | "tool"
-  content: string
-  timestamp?: Date
-}
-
-export interface ParsedSession extends Session {
-  turns: ConversationTurn[]
-}
-
-export interface SessionAnalysis {
-  summary: string
-  topics: string[]
-  languages: string[]
-  keyInsights: string[]
-  codeSnippets: Array<{
-    language: string
-    code: string
-    context: string
-  }>
-  problems: string[]
-  solutions: string[]
-  suggestedTitle: string
-  suggestedTags: string[]
-}
-
-export type SourceType =
-  | "claude-code"
-  | "cursor"
-  | "windsurf"
-  | "codex"
-  | "warp"
-  | "vscode-copilot"
-  | "aider"
-  | "continue"
-  | "zed"
-  | "unknown"
-
-export interface Scanner {
-  name: string
-  sourceType: SourceType
-  description: string
-  getSessionDirs(): string[]
-  scan(limit: number): Session[]
-  parse(filePath: string, maxTurns?: number): ParsedSession | null
-}

package/src/scanner/vscode-copilot.ts

@@ -1,125 +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, listDirs, safeReadJson, safeStats } from "./fs-utils"
-
-export const vscodeCopilotScanner: Scanner = {
-  name: "VS Code Copilot Chat",
-  sourceType: "vscode-copilot",
-  description: "GitHub Copilot Chat sessions in VS Code",
-
-  getSessionDirs(): string[] {
-    const home = getHome()
-    const platform = getPlatform()
-    const candidates: string[] = []
-    const variants = ["Code", "Code - Insiders", "VSCodium"]
-    for (const variant of variants) {
-      if (platform === "macos") {
-        candidates.push(path.join(home, "Library", "Application Support", variant, "User", "workspaceStorage"))
-        candidates.push(path.join(home, "Library", "Application Support", variant, "User", "globalStorage", "github.copilot-chat"))
-      } else if (platform === "windows") {
-        const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
-        candidates.push(path.join(appData, variant, "User", "workspaceStorage"))
-        candidates.push(path.join(appData, variant, "User", "globalStorage", "github.copilot-chat"))
-      } else {
-        candidates.push(path.join(home, ".config", variant, "User", "workspaceStorage"))
-        candidates.push(path.join(home, ".config", variant, "User", "globalStorage", "github.copilot-chat"))
-      }
-    }
-    return candidates.filter((d) => {
-      try { return fs.existsSync(d) } catch { return false }
-    })
-  },
-
-  scan(limit: number): Session[] {
-    const sessions: Session[] = []
-    for (const baseDir of this.getSessionDirs()) {
-      if (baseDir.includes("globalStorage")) {
-        for (const filePath of listFiles(baseDir, [".json"])) {
-          const session = tryParseConversationFile(filePath)
-          if (session) sessions.push(session)
-        }
-        continue
-      }
-      for (const hashDir of listDirs(baseDir)) {
-        for (const filePath of listFiles(path.join(hashDir, "github.copilot-chat"), [".json"])) {
-          const session = tryParseConversationFile(filePath)
-          if (session) sessions.push(session)
-        }
-      }
-    }
-    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 = extractCopilotTurns(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: "vscode-copilot",
-      project: path.basename(path.dirname(filePath)),
-      title: humanMsgs[0]?.content.slice(0, 80) || "Copilot Chat 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 tryParseConversationFile(filePath: string): Session | null {
-  const stats = safeStats(filePath)
-  if (!stats || stats.size < 100) return null
-  const data = safeReadJson<Record<string, unknown>>(filePath)
-  if (!data) return null
-  const turns = extractCopilotTurns(data)
-  if (turns.length < 2) return null
-  const humanMsgs = turns.filter((t) => t.role === "human")
-  const preview = humanMsgs[0]?.content.slice(0, 200) || "(copilot session)"
-  return {
-    id: path.basename(filePath, ".json"), source: "vscode-copilot",
-    project: path.basename(path.dirname(filePath)),
-    title: preview.slice(0, 80), messageCount: turns.length,
-    humanMessages: humanMsgs.length, aiMessages: turns.length - humanMsgs.length,
-    preview, filePath, modifiedAt: stats.mtime, sizeBytes: stats.size,
-  }
-}
-
-function extractCopilotTurns(data: Record<string, unknown>, maxTurns?: number): ConversationTurn[] {
-  const turns: ConversationTurn[] = []
-  if (Array.isArray(data.conversations)) {
-    for (const conv of data.conversations) {
-      if (!conv || typeof conv !== "object") continue
-      const c = conv as Record<string, unknown>
-      if (!Array.isArray(c.turns)) continue
-      for (const turn of c.turns) {
-        if (maxTurns && turns.length >= maxTurns) break
-        const t = turn as Record<string, unknown>
-        if (t.request && typeof t.request === "string") turns.push({ role: "human", content: t.request })
-        if (t.response && typeof t.response === "string") turns.push({ role: "assistant", content: t.response })
-        if (t.message && typeof t.message === "string") {
-          turns.push({ role: t.role === "user" ? "human" : "assistant", content: t.message })
-        }
-      }
-    }
-    return turns
-  }
-  for (const arr of [data.messages, data.history, data.entries]) {
-    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>
-      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/warp.ts

@@ -1,19 +0,0 @@
-import type { Scanner, Session, ParsedSession } from "./types"
-
-export const warpScanner: Scanner = {
-  name: "Warp Terminal",
-  sourceType: "warp",
-  description: "Warp Terminal (AI chat is cloud-only, no local history)",
-
-  getSessionDirs(): string[] {
-    return []
-  },
-
-  scan(_limit: number): Session[] {
-    return []
-  },
-
-  parse(_filePath: string, _maxTurns?: number): ParsedSession | null {
-    return null
-  },
-}

package/src/scanner/windsurf.ts

@@ -1,147 +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 { listDirs, safeReadJson, safeStats, extractProjectDescription } from "./fs-utils"
-
-interface VscdbChatIndex {
-  version: number
-  entries: Record<string, VscdbChatEntry>
-}
-
-interface VscdbChatEntry {
-  messages?: Array<{ role?: string; content?: string; text?: string }>
-  [key: string]: unknown
-}
-
-export const windsurfScanner: Scanner = {
-  name: "Windsurf",
-  sourceType: "windsurf",
-  description: "Windsurf (Codeium) Cascade chat sessions (SQLite)",
-
-  getSessionDirs(): string[] {
-    const home = getHome()
-    const platform = getPlatform()
-    const candidates: string[] = []
-    if (platform === "macos") {
-      candidates.push(path.join(home, "Library", "Application Support", "Windsurf", "User", "workspaceStorage"))
-    } else if (platform === "windows") {
-      const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
-      candidates.push(path.join(appData, "Windsurf", "User", "workspaceStorage"))
-    } else {
-      candidates.push(path.join(home, ".config", "Windsurf", "User", "workspaceStorage"))
-    }
-    return candidates.filter((d) => {
-      try { return fs.existsSync(d) } catch { return false }
-    })
-  },
-
-  scan(limit: number): Session[] {
-    const sessions: Session[] = []
-    for (const baseDir of this.getSessionDirs()) {
-      for (const wsDir of listDirs(baseDir)) {
-        const dbPath = path.join(wsDir, "state.vscdb")
-        if (!fs.existsSync(dbPath)) continue
-        const wsJson = safeReadJson<{ folder?: string }>(path.join(wsDir, "workspace.json"))
-        let projectPath: string | undefined
-        if (wsJson?.folder) {
-          try { projectPath = decodeURIComponent(new URL(wsJson.folder).pathname) } catch { /* */ }
-        }
-        const project = projectPath ? path.basename(projectPath) : path.basename(wsDir)
-        const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined
-        const chatData = readVscdbChatSessions(dbPath)
-        if (!chatData || Object.keys(chatData.entries).length === 0) continue
-        for (const [sessionId, entry] of Object.entries(chatData.entries)) {
-          const messages = extractVscdbMessages(entry)
-          if (messages.length < 2) continue
-          const humanMsgs = messages.filter((m) => m.role === "human")
-          const preview = humanMsgs[0]?.content.slice(0, 200) || "(windsurf session)"
-          const dbStats = safeStats(dbPath)
-          sessions.push({
-            id: sessionId, source: "windsurf", project, projectPath, projectDescription,
-            title: preview.slice(0, 80), messageCount: messages.length,
-            humanMessages: humanMsgs.length, aiMessages: messages.length - humanMsgs.length,
-            preview, filePath: `${dbPath}|${sessionId}`,
-            modifiedAt: dbStats?.mtime || new Date(), sizeBytes: dbStats?.size || 0,
-          })
-        }
-      }
-    }
-    sessions.sort((a, b) => b.modifiedAt.getTime() - a.modifiedAt.getTime())
-    return sessions.slice(0, limit)
-  },
-
-  parse(filePath: string, maxTurns?: number): ParsedSession | null {
-    const sepIdx = filePath.lastIndexOf("|")
-    const dbPath = sepIdx > 0 ? filePath.slice(0, sepIdx) : filePath
-    const targetSessionId = sepIdx > 0 ? filePath.slice(sepIdx + 1) : null
-    const chatData = readVscdbChatSessions(dbPath)
-    if (!chatData) return null
-    const stats = safeStats(dbPath)
-    const entries = Object.entries(chatData.entries)
-    if (entries.length === 0) return null
-    let targetEntry: VscdbChatEntry | null = null
-    let targetId = path.basename(path.dirname(dbPath))
-    if (targetSessionId && chatData.entries[targetSessionId]) {
-      targetEntry = chatData.entries[targetSessionId]
-      targetId = targetSessionId
-    } else {
-      for (const [id, entry] of entries) {
-        const msgs = extractVscdbMessages(entry)
-        if (msgs.length >= 2) { targetEntry = entry; targetId = id; break }
-      }
-    }
-    if (!targetEntry) return null
-    const allTurns = extractVscdbMessages(targetEntry)
-    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")
-    return {
-      id: targetId, source: "windsurf", project: path.basename(path.dirname(filePath)),
-      title: humanMsgs[0]?.content.slice(0, 80) || "Windsurf session",
-      messageCount: turns.length, humanMessages: humanMsgs.length, aiMessages: aiMsgs.length,
-      preview: humanMsgs[0]?.content.slice(0, 200) || "",
-      filePath: dbPath, modifiedAt: stats?.mtime || new Date(), sizeBytes: stats?.size || 0, turns,
-    }
-  },
-}
-
-function readVscdbChatSessions(dbPath: string): VscdbChatIndex | null {
-  try {
-    const db = new BunDatabase(dbPath, { readonly: true })
-    let row: { value: string | Buffer } | undefined
-    try {
-      row = db.prepare("SELECT value FROM ItemTable WHERE key = 'chat.ChatSessionStore.index'").get() as any
-    } finally { db.close() }
-    if (!row?.value) return null
-    const valueStr = typeof row.value === "string" ? row.value : (row.value as Buffer).toString("utf-8")
-    return JSON.parse(valueStr) as VscdbChatIndex
-  } catch { return null }
-}
-
-function extractVscdbMessages(entry: VscdbChatEntry): ConversationTurn[] {
-  const turns: ConversationTurn[] = []
-  if (Array.isArray(entry.messages)) {
-    for (const msg of entry.messages) {
-      if (!msg || typeof msg !== "object") continue
-      const content = msg.content || msg.text
-      if (typeof content !== "string" || !content.trim()) continue
-      turns.push({ role: msg.role === "user" || msg.role === "human" ? "human" : "assistant", content })
-    }
-    return turns
-  }
-  for (const [, value] of Object.entries(entry)) {
-    if (!Array.isArray(value)) continue
-    for (const item of value) {
-      if (!item || typeof item !== "object") continue
-      const m = item as Record<string, unknown>
-      const content = (m.content || m.text) as string | undefined
-      if (typeof content !== "string" || !content.trim()) continue
-      turns.push({ role: m.role === "user" || m.role === "human" ? "human" : "assistant", content })
-    }
-    if (turns.length > 0) return turns
-  }
-  return turns
-}

package/src/scanner/zed.ts

@@ -1,88 +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 zedScanner: Scanner = {
-  name: "Zed",
-  sourceType: "zed",
-  description: "Zed editor AI assistant conversations",
-
-  getSessionDirs(): string[] {
-    const home = getHome()
-    const platform = getPlatform()
-    const candidates: string[] = []
-    if (platform === "macos") {
-      candidates.push(path.join(home, "Library", "Application Support", "Zed", "conversations"))
-    }
-    if (platform === "windows") {
-      const appData = process.env.APPDATA || path.join(home, "AppData", "Roaming")
-      candidates.push(path.join(appData, "Zed", "conversations"))
-    }
-    candidates.push(path.join(home, ".config", "zed", "conversations"))
-    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", ".zed"], true)) {
-        const stats = safeStats(filePath)
-        if (!stats || stats.size < 100) continue
-        const data = safeReadJson<Record<string, unknown>>(filePath)
-        if (!data) continue
-        const turns = extractZedTurns(data)
-        if (turns.length < 2) continue
-        const humanMsgs = turns.filter((t) => t.role === "human")
-        const preview = humanMsgs[0]?.content.slice(0, 200) || "(zed session)"
-        sessions.push({
-          id: path.basename(filePath).replace(/\.\w+$/, ""), source: "zed",
-          project: (data.project 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 = extractZedTurns(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).replace(/\.\w+$/, ""), source: "zed",
-      project: (data.project as string) || path.basename(path.dirname(filePath)),
-      title: (data.title as string) || humanMsgs[0]?.content.slice(0, 80) || "Zed 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 extractZedTurns(data: Record<string, unknown>, maxTurns?: number): ConversationTurn[] {
-  const turns: ConversationTurn[] = []
-  for (const arr of [data.messages, data.conversation, data.entries]) {
-    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>
-      const content = (m.content || m.body || m.text) as string | undefined
-      if (typeof content !== "string") continue
-      turns.push({ role: m.role === "user" || m.role === "human" ? "human" : "assistant", content })
-    }
-    if (turns.length > 0) return turns
-  }
-  return turns
-}