codeblog-app 0.1.0

package/src/scanner/__tests__/registry.test.ts

@@ -0,0 +1,56 @@
+import { describe, test, expect, beforeEach } from "bun:test"
+import { registerScanner, getScanners, scanAll, listScannerStatus } from "../registry"
+import type { Scanner, Session, ParsedSession } from "../types"
+
+const mockScanner: Scanner = {
+  name: "Test Scanner",
+  source: "test" as any,
+  description: "A test scanner",
+  detect() {
+    return ["/tmp"]
+  },
+  scan(limit = 10): Session[] {
+    return [
+      {
+        id: "test-session-1",
+        title: "Test Session",
+        source: "test" as any,
+        project: "test-project",
+        filePath: "/tmp/test.json",
+        modifiedAt: new Date(),
+        humanMessages: 5,
+        aiMessages: 5,
+      },
+    ]
+  },
+  parse(filePath: string): ParsedSession | null {
+    return {
+      id: "test-session-1",
+      source: "test" as any,
+      project: "test-project",
+      projectPath: "/tmp/test-project",
+      turns: [
+        { role: "human", content: "Hello", timestamp: new Date() },
+        { role: "assistant", content: "Hi there!", timestamp: new Date() },
+      ],
+    }
+  },
+}
+
+describe("registry", () => {
+  test("registerScanner adds scanner", () => {
+    registerScanner(mockScanner)
+    const scanners = getScanners()
+    expect(scanners.some((s) => s.name === "Test Scanner")).toBe(true)
+  })
+
+  test("listScannerStatus returns status for all scanners", () => {
+    const statuses = listScannerStatus()
+    expect(statuses.length).toBeGreaterThan(0)
+    for (const status of statuses) {
+      expect(status.name).toBeDefined()
+      expect(status.source).toBeDefined()
+      expect(typeof status.available).toBe("boolean")
+    }
+  })
+})

package/src/scanner/aider.ts

@@ -0,0 +1,96 @@
+import * as path from "path"
+import * as fs from "fs"
+import type { Scanner, Session, ParsedSession, ConversationTurn } from "./types"
+import { getHome } from "./platform"
+import { listFiles, safeReadFile, safeStats } from "./fs-utils"
+
+export const aiderScanner: Scanner = {
+  name: "Aider",
+  sourceType: "aider",
+  description: "Aider AI pair programming sessions",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const candidates = [path.join(home, ".aider", "history"), path.join(home, ".aider")]
+    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, [".md"], true)) {
+        if (!path.basename(filePath).includes("aider")) continue
+        const stats = safeStats(filePath)
+        if (!stats || stats.size < 100) continue
+        const content = safeReadFile(filePath)
+        if (!content) continue
+        const { humanCount, aiCount, preview } = parseAiderMarkdown(content)
+        if (humanCount === 0) continue
+        sessions.push({
+          id: path.basename(filePath, ".md"), source: "aider",
+          project: path.basename(path.dirname(filePath)),
+          title: preview.slice(0, 80) || "Aider session",
+          messageCount: humanCount + aiCount, humanMessages: humanCount, aiMessages: aiCount,
+          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 content = safeReadFile(filePath)
+    if (!content) return null
+    const stats = safeStats(filePath)
+    const turns = parseAiderTurns(content, 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, ".md"), source: "aider",
+      project: path.basename(path.dirname(filePath)),
+      title: humanMsgs[0]?.content.slice(0, 80) || "Aider 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 parseAiderMarkdown(content: string) {
+  const userBlocks = content.split(/^####\s+/m).filter(Boolean)
+  let humanCount = 0
+  let aiCount = 0
+  let preview = ""
+  for (const block of userBlocks) {
+    const firstLine = block.split("\n")[0]?.trim()
+    if (firstLine) {
+      humanCount++
+      if (!preview) preview = firstLine.slice(0, 200)
+      const rest = block.split("\n").slice(1).join("\n").trim()
+      if (rest) aiCount++
+    }
+  }
+  return { humanCount, aiCount, preview }
+}
+
+function parseAiderTurns(content: string, maxTurns?: number): ConversationTurn[] {
+  const turns: ConversationTurn[] = []
+  for (const block of content.split(/^####\s+/m).filter(Boolean)) {
+    if (maxTurns && turns.length >= maxTurns) break
+    const lines = block.split("\n")
+    const userMsg = lines[0]?.trim()
+    if (userMsg) {
+      turns.push({ role: "human", content: userMsg })
+      const aiResponse = lines.slice(1).join("\n").trim()
+      if (aiResponse) {
+        if (maxTurns && turns.length >= maxTurns) break
+        turns.push({ role: "assistant", content: aiResponse })
+      }
+    }
+  }
+  return turns
+}

package/src/scanner/analyzer.ts

@@ -0,0 +1,237 @@
+import type { ParsedSession, SessionAnalysis, ConversationTurn } from "./types"
+
+export function analyzeSession(session: ParsedSession): SessionAnalysis {
+  const allContent = session.turns.map((t) => t.content).join("\n")
+  const humanContent = session.turns
+    .filter((t) => t.role === "human")
+    .map((t) => t.content)
+    .join("\n")
+  const aiContent = session.turns
+    .filter((t) => t.role === "assistant")
+    .map((t) => t.content)
+    .join("\n")
+
+  return {
+    summary: generateSummary(session),
+    topics: extractTopics(allContent),
+    languages: detectLanguages(allContent),
+    keyInsights: extractInsights(session.turns),
+    codeSnippets: extractCodeSnippets(allContent),
+    problems: extractProblems(humanContent),
+    solutions: extractSolutions(aiContent),
+    suggestedTitle: suggestTitle(session),
+    suggestedTags: suggestTags(allContent),
+  }
+}
+
+function generateSummary(session: ParsedSession): string {
+  const humanMsgs = session.turns.filter((t) => t.role === "human")
+  const problems = extractProblems(humanMsgs.map((t) => t.content).join("\n"))
+  const langs = detectLanguages(session.turns.map((t) => t.content).join("\n"))
+  const parts: string[] = []
+
+  if (problems.length > 0) {
+    parts.push(`Ran into ${problems.length > 1 ? "a few issues" : "an issue"} while working on ${session.project}`)
+  } else {
+    parts.push(`Worked on ${session.project}`)
+  }
+
+  if (langs.length > 0) parts.push(`using ${langs.slice(0, 3).join(", ")}`)
+
+  const firstTask = humanMsgs.find((m) => m.content.trim().length > 20)
+  if (firstTask) {
+    const task = firstTask.content.split("\n")[0].trim().slice(0, 120)
+    parts.push(`— started with: "${task}"`)
+  }
+
+  return parts.join(" ") + "."
+}
+
+function extractTopics(content: string): string[] {
+  const topics: Set<string> = new Set()
+  const patterns: [RegExp, string][] = [
+    [/\b(react|vue|angular|svelte|nextjs|next\.js|nuxt)\b/i, "frontend"],
+    [/\b(express|fastify|koa|nest\.?js|django|flask|rails)\b/i, "backend"],
+    [/\b(typescript|javascript|python|rust|go|java|c\+\+|ruby|swift|kotlin)\b/i, "programming-language"],
+    [/\b(docker|kubernetes|k8s|ci\/cd|deploy|devops)\b/i, "devops"],
+    [/\b(sql|postgres|mysql|mongodb|redis|database|prisma|drizzle)\b/i, "database"],
+    [/\b(test|jest|vitest|pytest|testing|spec|unit test)\b/i, "testing"],
+    [/\b(api|rest|graphql|grpc|websocket)\b/i, "api"],
+    [/\b(auth|jwt|oauth|session|login|password)\b/i, "authentication"],
+    [/\b(css|tailwind|styled|sass|scss|styling)\b/i, "styling"],
+    [/\b(git|merge|rebase|branch|commit)\b/i, "git"],
+    [/\b(performance|optimize|cache|lazy|memo)\b/i, "performance"],
+    [/\b(debug|error|bug|fix|issue|crash)\b/i, "debugging"],
+    [/\b(refactor|clean|architecture|pattern|design)\b/i, "architecture"],
+    [/\b(security|vulnerability|xss|csrf|injection)\b/i, "security"],
+    [/\b(ai|ml|llm|gpt|claude|model|prompt)\b/i, "ai-ml"],
+  ]
+  for (const [pattern, topic] of patterns) {
+    if (pattern.test(content)) topics.add(topic)
+  }
+  return Array.from(topics)
+}
+
+function detectLanguages(content: string): string[] {
+  const langs: Set<string> = new Set()
+  const patterns: [RegExp, string][] = [
+    [/```(?:typescript|tsx?)\b/i, "TypeScript"],
+    [/```(?:javascript|jsx?)\b/i, "JavaScript"],
+    [/```python\b/i, "Python"],
+    [/```rust\b/i, "Rust"],
+    [/```go\b/i, "Go"],
+    [/```java\b/i, "Java"],
+    [/```(?:c\+\+|cpp)\b/i, "C++"],
+    [/```c\b/i, "C"],
+    [/```ruby\b/i, "Ruby"],
+    [/```swift\b/i, "Swift"],
+    [/```kotlin\b/i, "Kotlin"],
+    [/```(?:bash|sh|shell|zsh)\b/i, "Shell"],
+    [/```sql\b/i, "SQL"],
+    [/```html\b/i, "HTML"],
+    [/```css\b/i, "CSS"],
+    [/```yaml\b/i, "YAML"],
+    [/```json\b/i, "JSON"],
+    [/```(?:dockerfile|docker)\b/i, "Docker"],
+  ]
+  for (const [pattern, lang] of patterns) {
+    if (pattern.test(content)) langs.add(lang)
+  }
+  if (langs.size === 0) {
+    if (/\bimport\s+.*\s+from\s+['"]/.test(content)) langs.add("JavaScript/TypeScript")
+    if (/\bdef\s+\w+\s*\(/.test(content)) langs.add("Python")
+    if (/\bfn\s+\w+\s*\(/.test(content)) langs.add("Rust")
+    if (/\bfunc\s+\w+\s*\(/.test(content)) langs.add("Go")
+  }
+  return Array.from(langs)
+}
+
+function extractInsights(turns: ConversationTurn[]): string[] {
+  const insights: string[] = []
+  for (const turn of turns) {
+    if (turn.role !== "assistant") continue
+    const patterns = [
+      /(?:the (?:issue|problem|bug|root cause) (?:is|was))\s+(.{20,150})/i,
+      /(?:the (?:solution|fix|answer) (?:is|was))\s+(.{20,150})/i,
+      /(?:you (?:should|need to|can))\s+(.{20,150})/i,
+      /(?:this (?:happens|occurs) because)\s+(.{20,150})/i,
+    ]
+    for (const pattern of patterns) {
+      const match = turn.content.match(pattern)
+      if (match?.[1]) insights.push(match[1].trim().replace(/\.$/, ""))
+    }
+  }
+  return [...new Set(insights)].slice(0, 10)
+}
+
+function extractCodeSnippets(content: string): Array<{ language: string; code: string; context: string }> {
+  const snippets: Array<{ language: string; code: string; context: string }> = []
+  const regex = /```(\w*)\n([\s\S]*?)```/g
+  let match
+  while ((match = regex.exec(content)) !== null) {
+    const language = match[1] || "unknown"
+    const code = match[2].trim()
+    if (code.length < 10 || code.length > 2000) continue
+    const beforeIdx = Math.max(0, match.index - 200)
+    const context = content.slice(beforeIdx, match.index).trim().split("\n").pop() || ""
+    snippets.push({ language, code, context })
+  }
+  return snippets.slice(0, 10)
+}
+
+function extractProblems(humanContent: string): string[] {
+  const problems: string[] = []
+  for (const line of humanContent.split("\n")) {
+    const trimmed = line.trim()
+    if (trimmed.length < 15 || trimmed.length > 300) continue
+    if (
+      /\b(error|bug|issue|problem|broken|doesn't work|not working|failing|crash|wrong)\b/i.test(trimmed) &&
+      !trimmed.startsWith("//") &&
+      !trimmed.startsWith("#")
+    ) {
+      problems.push(trimmed)
+    }
+  }
+  return [...new Set(problems)].slice(0, 5)
+}
+
+function extractSolutions(aiContent: string): string[] {
+  const solutions: string[] = []
+  for (const sentence of aiContent.split(/[.!]\s+/)) {
+    const trimmed = sentence.trim()
+    if (trimmed.length < 20 || trimmed.length > 300) continue
+    if (
+      /\b(fix|solve|solution|resolve|instead|should|try|change|update|replace|use)\b/i.test(trimmed) &&
+      !/\b(error|bug|issue|problem)\b/i.test(trimmed)
+    ) {
+      solutions.push(trimmed)
+    }
+  }
+  return [...new Set(solutions)].slice(0, 5)
+}
+
+function suggestTitle(session: ParsedSession): string {
+  const allContent = session.turns.map((t) => t.content).join("\n")
+  const humanContent = session.turns.filter((t) => t.role === "human").map((t) => t.content).join("\n")
+  const problems = extractProblems(humanContent)
+  const solutions = extractSolutions(
+    session.turns.filter((t) => t.role === "assistant").map((t) => t.content).join("\n"),
+  )
+  const langs = detectLanguages(allContent)
+  const topics = extractTopics(allContent)
+  const langStr = langs.slice(0, 2).join("/") || "code"
+  const project = session.project || "my project"
+
+  if (problems.length > 0) {
+    const problem = problems[0].slice(0, 60).replace(/\n/g, " ")
+    return `Debugging ${langStr}: ${problem}`
+  }
+  if (solutions.length > 0) {
+    const solution = solutions[0].slice(0, 60).replace(/\n/g, " ")
+    return `How I ${solution.toLowerCase().replace(/^(you |we |i )?(should |need to |can )?/i, "")}`
+  }
+  if (topics.length > 0) {
+    const topicStr = topics.slice(0, 2).join(" + ")
+    return `Working with ${topicStr} in ${project}`
+  }
+  const firstHuman = session.turns.find((t) => t.role === "human")
+  if (firstHuman) {
+    const cleaned = firstHuman.content.split("\n")[0].trim().slice(0, 80)
+    if (cleaned.length > 15) return cleaned
+  }
+  return `${langStr} session: things I learned in ${project}`
+}
+
+function suggestTags(content: string): string[] {
+  const tags: Set<string> = new Set()
+  const patterns: [RegExp, string][] = [
+    [/\breact\b/i, "react"],
+    [/\bnext\.?js\b/i, "nextjs"],
+    [/\btypescript\b/i, "typescript"],
+    [/\bpython\b/i, "python"],
+    [/\brust\b/i, "rust"],
+    [/\bdocker\b/i, "docker"],
+    [/\bprisma\b/i, "prisma"],
+    [/\btailwind\b/i, "tailwindcss"],
+    [/\bnode\.?js\b/i, "nodejs"],
+    [/\bgit\b/i, "git"],
+    [/\bpostgres\b/i, "postgresql"],
+    [/\bmongodb\b/i, "mongodb"],
+    [/\bredis\b/i, "redis"],
+    [/\baws\b/i, "aws"],
+    [/\bvue\b/i, "vue"],
+    [/\bangular\b/i, "angular"],
+    [/\bsvelte\b/i, "svelte"],
+    [/\bgraphql\b/i, "graphql"],
+    [/\bwebsocket\b/i, "websocket"],
+  ]
+  for (const [pattern, tag] of patterns) {
+    if (pattern.test(content)) tags.add(tag)
+  }
+  if (/\b(bug|fix|error|debug)\b/i.test(content)) tags.add("bug-fix")
+  if (/\b(refactor|clean|restructure)\b/i.test(content)) tags.add("refactoring")
+  if (/\b(performance|optimize|speed|cache)\b/i.test(content)) tags.add("performance")
+  if (/\b(test|spec|coverage)\b/i.test(content)) tags.add("testing")
+  if (/\b(deploy|ci|cd|pipeline)\b/i.test(content)) tags.add("devops")
+  return Array.from(tags).slice(0, 8)
+}

package/src/scanner/claude-code.ts

@@ -0,0 +1,188 @@
+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, safeStats, readJsonl, extractProjectDescription } from "./fs-utils"
+
+interface ClaudeMessage {
+  type: string
+  cwd?: string
+  message?: {
+    role?: string
+    content?: string | Array<{ type: string; text?: string }>
+  }
+  timestamp?: string
+}
+
+export const claudeCodeScanner: Scanner = {
+  name: "Claude Code",
+  sourceType: "claude-code",
+  description: "Claude Code CLI sessions (~/.claude/projects/)",
+
+  getSessionDirs(): string[] {
+    const home = getHome()
+    const candidates = [path.join(home, ".claude", "projects")]
+    return candidates.filter((d) => {
+      try { return fs.existsSync(d) } catch { return false }
+    })
+  },
+
+  scan(limit: number): Session[] {
+    const sessions: Session[] = []
+    const dirs = this.getSessionDirs()
+
+    for (const baseDir of dirs) {
+      const projectDirs = listDirs(baseDir)
+      for (const projectDir of projectDirs) {
+        const project = path.basename(projectDir)
+        const files = listFiles(projectDir, [".jsonl"])
+
+        for (const filePath of files) {
+          const stats = safeStats(filePath)
+          if (!stats) continue
+
+          const lines = readJsonl<ClaudeMessage>(filePath)
+          if (lines.length < 3) continue
+
+          const humanMsgs = lines.filter((l) => l.type === "user")
+          const aiMsgs = lines.filter((l) => l.type === "assistant")
+
+          const cwdLine = lines.find((l) => l.cwd)
+          let projectPath = cwdLine?.cwd || null
+
+          if (!projectPath && project.startsWith("-")) {
+            projectPath = decodeClaudeProjectDir(project)
+          }
+          const projectName = projectPath ? path.basename(projectPath) : project
+
+          const projectDescription = projectPath ? extractProjectDescription(projectPath) : null
+
+          let preview = ""
+          for (const msg of humanMsgs.slice(0, 8)) {
+            const content = extractContent(msg)
+            if (!content || content.length < 10) continue
+            if (content.startsWith("<local-command-caveat>")) continue
+            if (content.startsWith("<environment_context>")) continue
+            if (content.startsWith("<command-name>")) continue
+            preview = content.slice(0, 200)
+            break
+          }
+
+          sessions.push({
+            id: path.basename(filePath, ".jsonl"),
+            source: "claude-code",
+            project: projectName,
+            projectPath: projectPath || undefined,
+            projectDescription: projectDescription || undefined,
+            title: preview.slice(0, 80) || `Claude session in ${projectName}`,
+            messageCount: humanMsgs.length + aiMsgs.length,
+            humanMessages: humanMsgs.length,
+            aiMessages: aiMsgs.length,
+            preview: preview || "(no 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<ClaudeMessage>(filePath)
+    if (lines.length === 0) return null
+
+    const stats = safeStats(filePath)
+    const turns: ConversationTurn[] = []
+
+    const cwdLine = lines.find((l) => l.cwd)
+    const projectPath = cwdLine?.cwd || undefined
+    const projectName = projectPath ? path.basename(projectPath) : path.basename(path.dirname(filePath))
+    const projectDescription = projectPath ? extractProjectDescription(projectPath) || undefined : undefined
+
+    for (const line of lines) {
+      if (maxTurns && turns.length >= maxTurns) break
+      if (line.type !== "user" && line.type !== "assistant") continue
+      const content = extractContent(line)
+      if (!content) continue
+      turns.push({
+        role: line.type === "user" ? "human" : "assistant",
+        content,
+        timestamp: line.timestamp ? new Date(line.timestamp) : undefined,
+      })
+    }
+
+    const humanMsgs = turns.filter((t) => t.role === "human")
+    const aiMsgs = turns.filter((t) => t.role === "assistant")
+
+    return {
+      id: path.basename(filePath, ".jsonl"),
+      source: "claude-code",
+      project: projectName,
+      projectPath,
+      projectDescription,
+      title: humanMsgs[0]?.content.slice(0, 80) || "Claude 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 decodeClaudeProjectDir(dirName: string): string | null {
+  const platform = getPlatform()
+  const stripped = dirName.startsWith("-") ? dirName.slice(1) : dirName
+  const parts = stripped.split("-")
+  let currentPath = ""
+  let i = 0
+
+  if (platform === "windows" && parts.length > 0 && /^[a-zA-Z]$/.test(parts[0])) {
+    currentPath = parts[0].toUpperCase() + ":"
+    i = 1
+  }
+
+  while (i < parts.length) {
+    let bestMatch = ""
+    let bestLen = 0
+    for (let end = parts.length; end > i; end--) {
+      const segment = parts.slice(i, end).join("-")
+      const candidate = currentPath + path.sep + segment
+      try {
+        if (fs.existsSync(candidate)) {
+          bestMatch = candidate
+          bestLen = end - i
+          break
+        }
+      } catch { /* ignore */ }
+    }
+    if (bestLen > 0) {
+      currentPath = bestMatch
+      i += bestLen
+    } else {
+      currentPath += path.sep + parts[i]
+      i++
+    }
+  }
+
+  return currentPath || null
+}
+
+function extractContent(msg: ClaudeMessage): string {
+  if (!msg.message?.content) return ""
+  if (typeof msg.message.content === "string") return msg.message.content
+  if (Array.isArray(msg.message.content)) {
+    return msg.message.content
+      .filter((c) => c.type === "text" && c.text)
+      .map((c) => c.text!)
+      .join("\n")
+  }
+  return ""
+}