@cuongtran001/kanna 0.39.2

package/src/server/claude-session-importer.ts

@@ -0,0 +1,187 @@
+import { statSync } from "node:fs"
+import { homedir } from "node:os"
+import type { EventStore } from "./event-store"
+import type { ChatRecord } from "./events"
+import { mapClaudeRecordsToEntries } from "./claude-session-mapper"
+import { scanClaudeSessions } from "./claude-session-scanner"
+import type { ParsedClaudeSession } from "./claude-session-types"
+
+export interface ImportClaudeSessionsResult {
+  imported: number    // brand new sessions
+  updated: number     // existing sessions whose hash changed; new messages appended
+  skipped: number     // unchanged (hash match) or empty-entry sessions
+  failed: number      // cwd missing or store error
+  newProjects: number
+}
+
+export interface ImportClaudeSessionsArgs {
+  store: EventStore
+  homeDir?: string
+  onProgress?: (update: { scanned: number; imported: number }) => void
+}
+
+function cwdExists(cwd: string): boolean {
+  if (!cwd) return false
+  try {
+    return statSync(cwd).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function extractUserText(content: unknown): string | null {
+  if (typeof content === "string") {
+    const trimmed = content.trim()
+    return trimmed ? trimmed : null
+  }
+  if (!Array.isArray(content)) return null
+  for (const block of content) {
+    if (!block || typeof block !== "object") continue
+    const blockRec = block as { type?: unknown; text?: unknown }
+    if (blockRec.type === "text" && typeof blockRec.text === "string") {
+      const trimmed = blockRec.text.trim()
+      if (trimmed) return trimmed
+    }
+  }
+  return null
+}
+
+function deriveTitle(session: ParsedClaudeSession): string {
+  for (const record of session.records) {
+    if (record.type !== "user") continue
+    const content = (record as { message?: { content?: unknown } }).message?.content
+    const text = extractUserText(content)
+    if (text) return text.slice(0, 60)
+  }
+  return "Imported session"
+}
+
+/**
+ * Extract the source record uuid from an entry _id.
+ * Mapper format: `${uuid}-user`, `${uuid}-text-<n>`, `${uuid}-tool_call-<n>`,
+ * `${uuid}-tool_result-<n>`. We match known trailing suffixes so that UUID v4
+ * values (which contain dashes) are not split incorrectly.
+ */
+function extractUuidFromEntryId(entryId: string): string | null {
+  const match = entryId.match(/^(.+)-(?:user|text-\d+|tool_call-\d+|tool_result-\d+)$/)
+  return match ? match[1] : null
+}
+
+/**
+ * Collect the set of record uuids already stored for a chat.
+ * Entries with a random uuid prefix (records that had no uuid) will always
+ * be absent from any record.uuid lookup — assumed acceptable since real Claude
+ * sessions always include uuid.
+ */
+function collectExistingUuids(store: EventStore, chatId: string): Set<string> {
+  const seen = new Set<string>()
+  for (const entry of store.getMessages(chatId)) {
+    const uuid = extractUuidFromEntryId(entry._id)
+    if (uuid) seen.add(uuid)
+  }
+  return seen
+}
+
+async function applyDelta(
+  store: EventStore,
+  chatId: string,
+  session: ParsedClaudeSession,
+): Promise<number> {
+  const seen = collectExistingUuids(store, chatId)
+  const newRecords = session.records.filter(
+    (record) => !record.uuid || !seen.has(record.uuid),
+  )
+  if (newRecords.length === 0) return 0
+
+  const entries = mapClaudeRecordsToEntries(newRecords)
+  for (const entry of entries) {
+    await store.appendMessage(chatId, entry)
+  }
+  return entries.length
+}
+
+export async function importClaudeSessions(
+  args: ImportClaudeSessionsArgs,
+): Promise<ImportClaudeSessionsResult> {
+  const { store, homeDir = homedir(), onProgress } = args
+  const sessions = scanClaudeSessions(homeDir)
+
+  let imported = 0
+  let updated = 0
+  let skipped = 0
+  let failed = 0
+  let newProjects = 0
+
+  let scanned = 0
+  for (const session of sessions) {
+    scanned += 1
+    if (onProgress) onProgress({ scanned, imported })
+
+    // Check if a chat already exists for this sessionId
+    let existingChat: ChatRecord | undefined
+    for (const chat of store.state.chatsById.values()) {
+      if (!chat.deletedAt && chat.sessionToken === session.sessionId) {
+        existingChat = chat
+        break
+      }
+    }
+
+    if (existingChat) {
+      // Hash match → nothing new to do
+      if (existingChat.sourceHash === session.sourceHash) {
+        skipped += 1
+        continue
+      }
+      // Hash changed → append only new records
+      try {
+        const appended = await applyDelta(store, existingChat.id, session)
+        if (appended > 0) {
+          updated += 1
+        } else {
+          skipped += 1
+        }
+        await store.setSourceHash(existingChat.id, session.sourceHash)
+      } catch (error) {
+        console.error("[kanna/import] failed to update session", session.filePath, error)
+        failed += 1
+      }
+      continue
+    }
+
+    // No existing chat — new import path
+    if (!cwdExists(session.cwd)) {
+      failed += 1
+      continue
+    }
+
+    const entries = mapClaudeRecordsToEntries(session.records)
+    if (entries.length === 0) {
+      skipped += 1
+      continue
+    }
+
+    try {
+      const projectBefore = store.state.projectIdsByPath.get(session.cwd)
+      const project = await store.openProject(session.cwd)
+      if (!projectBefore) newProjects += 1
+
+      const chat = await store.createChat(project.id)
+      await store.setChatProvider(chat.id, "claude")
+      await store.renameChat(chat.id, deriveTitle(session))
+
+      for (const entry of entries) {
+        await store.appendMessage(chat.id, entry)
+      }
+
+      await store.setSessionToken(chat.id, session.sessionId)
+      await store.setSourceHash(chat.id, session.sourceHash)
+      imported += 1
+      if (onProgress) onProgress({ scanned, imported })
+    } catch (error) {
+      console.error("[kanna/import] failed to import session", session.filePath, error)
+      failed += 1
+    }
+  }
+
+  return { imported, updated, skipped, failed, newProjects }
+}

package/src/server/claude-session-mapper.test.ts

@@ -0,0 +1,88 @@
+import { describe, expect, test } from "bun:test"
+import { mapClaudeRecordsToEntries } from "./claude-session-mapper"
+import type { ClaudeSessionRecord } from "./claude-session-types"
+
+describe("mapClaudeRecordsToEntries", () => {
+  const baseTs = "2026-04-20T10:00:00.000Z"
+
+  test("user message → user_prompt entry", () => {
+    const records: ClaudeSessionRecord[] = [
+      { type: "user", uuid: "u1", timestamp: baseTs, message: { role: "user", content: "hello" } },
+    ]
+    const entries = mapClaudeRecordsToEntries(records)
+    expect(entries.length).toBe(1)
+    expect(entries[0].kind).toBe("user_prompt")
+    if (entries[0].kind === "user_prompt") {
+      expect(entries[0].content).toBe("hello")
+    }
+  })
+
+  test("assistant text → assistant_text entry", () => {
+    const records: ClaudeSessionRecord[] = [
+      {
+        type: "assistant",
+        uuid: "a1",
+        timestamp: baseTs,
+        message: { role: "assistant", id: "m1", content: [{ type: "text", text: "hi" }] },
+      },
+    ]
+    const entries = mapClaudeRecordsToEntries(records)
+    expect(entries.length).toBe(1)
+    expect(entries[0].kind).toBe("assistant_text")
+    if (entries[0].kind === "assistant_text") {
+      expect(entries[0].text).toBe("hi")
+    }
+  })
+
+  test("assistant tool_use → tool_call entry with normalized Bash tool", () => {
+    const records: ClaudeSessionRecord[] = [
+      {
+        type: "assistant",
+        uuid: "a2",
+        timestamp: baseTs,
+        message: {
+          role: "assistant",
+          content: [{ type: "tool_use", id: "tu-1", name: "Bash", input: { command: "ls" } }],
+        },
+      },
+    ]
+    const entries = mapClaudeRecordsToEntries(records)
+    expect(entries.length).toBe(1)
+    expect(entries[0].kind).toBe("tool_call")
+    if (entries[0].kind === "tool_call") {
+      expect(entries[0].tool.toolKind).toBe("bash")
+      expect(entries[0].tool.toolId).toBe("tu-1")
+    }
+  })
+
+  test("user tool_result → tool_result entry", () => {
+    const records: ClaudeSessionRecord[] = [
+      {
+        type: "user",
+        uuid: "u1",
+        timestamp: baseTs,
+        message: {
+          role: "user",
+          content: [{ type: "tool_result", tool_use_id: "tu-1", content: "file1\nfile2" }],
+        },
+      },
+    ]
+    const entries = mapClaudeRecordsToEntries(records)
+    expect(entries.length).toBe(1)
+    expect(entries[0].kind).toBe("tool_result")
+    if (entries[0].kind === "tool_result") {
+      expect(entries[0].toolId).toBe("tu-1")
+      expect(entries[0].content).toBe("file1\nfile2")
+    }
+  })
+
+  test("skips summary and system records", () => {
+    const records: ClaudeSessionRecord[] = [
+      { type: "summary", summary: "x" },
+      { type: "system", content: "y" },
+      { type: "user", uuid: "u1", timestamp: baseTs, message: { role: "user", content: "hi" } },
+    ]
+    const entries = mapClaudeRecordsToEntries(records)
+    expect(entries.length).toBe(1)
+  })
+})

package/src/server/claude-session-mapper.ts

@@ -0,0 +1,106 @@
+import { normalizeToolCall } from "../shared/tools"
+import type {
+  AssistantTextEntry,
+  ToolCallEntry,
+  ToolResultEntry,
+  TranscriptEntry,
+  UserPromptEntry,
+} from "../shared/types"
+import type {
+  ClaudeSessionAssistantRecord,
+  ClaudeSessionRecord,
+  ClaudeSessionUserRecord,
+} from "./claude-session-types"
+
+function toMillis(value: string | undefined): number {
+  if (!value) return Date.now()
+  const parsed = Date.parse(value)
+  return Number.isFinite(parsed) ? parsed : Date.now()
+}
+
+function makeId(uuid: string | undefined, suffix: string): string {
+  if (uuid) return `${uuid}-${suffix}`
+  return `${crypto.randomUUID()}-${suffix}`
+}
+
+function mapUserRecord(record: ClaudeSessionUserRecord): TranscriptEntry[] {
+  const createdAt = toMillis(record.timestamp)
+  const content = record.message.content
+
+  if (typeof content === "string") {
+    const entry: UserPromptEntry = {
+      _id: makeId(record.uuid, "user"),
+      kind: "user_prompt",
+      createdAt,
+      content,
+    }
+    return [entry]
+  }
+
+  const entries: TranscriptEntry[] = []
+  for (let i = 0; i < content.length; i += 1) {
+    const block = content[i]
+    if (block.type === "tool_result") {
+      const resultEntry: ToolResultEntry = {
+        _id: makeId(record.uuid, `tool_result-${i}`),
+        kind: "tool_result",
+        createdAt,
+        toolId: block.tool_use_id,
+        content: typeof block.content === "string" ? block.content : block.content ?? null,
+        isError: block.is_error === true,
+      }
+      entries.push(resultEntry)
+    }
+  }
+  return entries
+}
+
+function mapAssistantRecord(record: ClaudeSessionAssistantRecord): TranscriptEntry[] {
+  const createdAt = toMillis(record.timestamp)
+  const messageId = record.message.id
+
+  const entries: TranscriptEntry[] = []
+  for (let i = 0; i < record.message.content.length; i += 1) {
+    const block = record.message.content[i]
+    if (block.type === "text") {
+      const entry: AssistantTextEntry = {
+        _id: makeId(record.uuid, `text-${i}`),
+        messageId,
+        kind: "assistant_text",
+        createdAt,
+        text: block.text,
+      }
+      entries.push(entry)
+      continue
+    }
+    if (block.type === "tool_use") {
+      const tool = normalizeToolCall({
+        toolName: block.name,
+        toolId: block.id,
+        input: block.input ?? {},
+      })
+      const entry: ToolCallEntry = {
+        _id: makeId(record.uuid, `tool_call-${i}`),
+        messageId,
+        kind: "tool_call",
+        createdAt,
+        tool,
+      }
+      entries.push(entry)
+    }
+  }
+  return entries
+}
+
+export function mapClaudeRecordsToEntries(records: ClaudeSessionRecord[]): TranscriptEntry[] {
+  const entries: TranscriptEntry[] = []
+  for (const record of records) {
+    if (record.type === "user") {
+      entries.push(...mapUserRecord(record as ClaudeSessionUserRecord))
+    } else if (record.type === "assistant") {
+      entries.push(...mapAssistantRecord(record as ClaudeSessionAssistantRecord))
+    }
+    // summary / system / other: skipped
+  }
+  return entries
+}

package/src/server/claude-session-parser.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, test } from "bun:test"
+import path from "node:path"
+import { parseClaudeSessionFile } from "./claude-session-parser"
+
+const FIXTURE_DIR = path.join(__dirname, "__fixtures__")
+
+describe("parseClaudeSessionFile", () => {
+  test("parses valid session with user, assistant, tool_use, tool_result", () => {
+    const parsed = parseClaudeSessionFile(path.join(FIXTURE_DIR, "claude-session-valid.jsonl"))
+    expect(parsed).not.toBeNull()
+    if (!parsed) return
+    expect(parsed.sessionId).toBe("sess-abc")
+    expect(parsed.cwd).toBe("/tmp/kanna-test-proj")
+    expect(parsed.records.length).toBe(6)
+    expect(parsed.firstTimestamp).toBeGreaterThan(0)
+    expect(parsed.lastTimestamp).toBeGreaterThanOrEqual(parsed.firstTimestamp)
+    expect(typeof parsed.sourceHash).toBe("string")
+    expect(parsed.sourceHash.length).toBe(32)  // md5 hex = 32 chars
+  })
+
+  test("skips malformed lines, keeps valid ones", () => {
+    const parsed = parseClaudeSessionFile(path.join(FIXTURE_DIR, "claude-session-malformed.jsonl"))
+    expect(parsed).not.toBeNull()
+    if (!parsed) return
+    expect(parsed.records.length).toBe(2)
+    expect(parsed.sessionId).toBe("sess-bad")
+  })
+
+  test("returns null for empty file", () => {
+    const parsed = parseClaudeSessionFile(path.join(FIXTURE_DIR, "claude-session-empty.jsonl"))
+    expect(parsed).toBeNull()
+  })
+
+  test("returns null for missing file", () => {
+    const parsed = parseClaudeSessionFile(path.join(FIXTURE_DIR, "does-not-exist.jsonl"))
+    expect(parsed).toBeNull()
+  })
+})

package/src/server/claude-session-parser.ts

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto"
+import { readFileSync, statSync } from "node:fs"
+import type { ClaudeSessionRecord, ParsedClaudeSession } from "./claude-session-types"
+
+function tryParse(line: string): ClaudeSessionRecord | null {
+  try {
+    const parsed = JSON.parse(line)
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return null
+    if (typeof (parsed as ClaudeSessionRecord).type !== "string") return null
+    return parsed as ClaudeSessionRecord
+  } catch {
+    return null
+  }
+}
+
+export function parseClaudeSessionFile(filePath: string): ParsedClaudeSession | null {
+  let raw: string
+  try {
+    raw = readFileSync(filePath, "utf8")
+  } catch {
+    return null
+  }
+  const sourceHash = createHash("md5").update(raw).digest("hex")
+
+  const records: ClaudeSessionRecord[] = []
+  let sessionId: string | null = null
+  let cwd: string | null = null
+  let first = Number.POSITIVE_INFINITY
+  let last = Number.NEGATIVE_INFINITY
+
+  for (const line of raw.split("\n")) {
+    const trimmed = line.trim()
+    if (!trimmed) continue
+    const record = tryParse(trimmed)
+    if (!record) continue
+
+    if (!sessionId && typeof record.sessionId === "string") sessionId = record.sessionId
+    if (!cwd && typeof record.cwd === "string") cwd = record.cwd
+
+    const ts = typeof record.timestamp === "string" ? Date.parse(record.timestamp) : Number.NaN
+    if (!Number.isNaN(ts)) {
+      if (ts < first) first = ts
+      if (ts > last) last = ts
+    }
+
+    records.push(record)
+  }
+
+  if (!sessionId) return null
+  if (records.length === 0) return null
+
+  let mtime: number
+  try {
+    mtime = statSync(filePath).mtimeMs
+  } catch {
+    mtime = Date.now()
+  }
+  return {
+    sessionId,
+    filePath,
+    cwd: cwd ?? "",
+    firstTimestamp: Number.isFinite(first) ? first : mtime,
+    lastTimestamp: Number.isFinite(last) ? last : mtime,
+    records,
+    sourceHash,
+  }
+}

package/src/server/claude-session-scanner.test.ts

@@ -0,0 +1,49 @@
+import { describe, expect, test } from "bun:test"
+import { mkdirSync, mkdtempSync, writeFileSync, rmSync } from "node:fs"
+import { tmpdir } from "node:os"
+import path from "node:path"
+import { scanClaudeSessions } from "./claude-session-scanner"
+
+function makeTempClaudeHome(): { home: string; cleanup: () => void } {
+  const home = mkdtempSync(path.join(tmpdir(), "kanna-claude-home-"))
+  return { home, cleanup: () => rmSync(home, { recursive: true, force: true }) }
+}
+
+describe("scanClaudeSessions", () => {
+  test("returns empty list when ~/.claude/projects missing", () => {
+    const { home, cleanup } = makeTempClaudeHome()
+    try {
+      expect(scanClaudeSessions(home)).toEqual([])
+    } finally {
+      cleanup()
+    }
+  })
+
+  test("discovers session files inside project folders", () => {
+    const { home, cleanup } = makeTempClaudeHome()
+    try {
+      const realProj = mkdtempSync(path.join(tmpdir(), "kanna-proj-"))
+      const folderName = realProj.replace(/\//g, "-")
+      const projDir = path.join(home, ".claude", "projects", folderName)
+      mkdirSync(projDir, { recursive: true })
+      const sessionPath = path.join(projDir, "sess-abc.jsonl")
+      const line = JSON.stringify({
+        type: "user",
+        uuid: "u1",
+        sessionId: "sess-abc",
+        cwd: realProj,
+        timestamp: "2026-04-20T10:00:00.000Z",
+        message: { role: "user", content: "hi" },
+      })
+      writeFileSync(sessionPath, `${line}\n`, "utf8")
+
+      const sessions = scanClaudeSessions(home)
+      expect(sessions.length).toBe(1)
+      expect(sessions[0].sessionId).toBe("sess-abc")
+      expect(sessions[0].filePath).toBe(sessionPath)
+      rmSync(realProj, { recursive: true, force: true })
+    } finally {
+      cleanup()
+    }
+  })
+})

package/src/server/claude-session-scanner.ts

@@ -0,0 +1,24 @@
+import { existsSync, readdirSync } from "node:fs"
+import { homedir } from "node:os"
+import path from "node:path"
+import type { ParsedClaudeSession } from "./claude-session-types"
+import { parseClaudeSessionFile } from "./claude-session-parser"
+
+export function scanClaudeSessions(homeDir: string = homedir()): ParsedClaudeSession[] {
+  const projectsDir = path.join(homeDir, ".claude", "projects")
+  if (!existsSync(projectsDir)) return []
+
+  const sessions: ParsedClaudeSession[] = []
+  for (const entry of readdirSync(projectsDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) continue
+    const projDir = path.join(projectsDir, entry.name)
+
+    for (const file of readdirSync(projDir, { withFileTypes: true })) {
+      if (!file.isFile() || !file.name.endsWith(".jsonl")) continue
+      const parsed = parseClaudeSessionFile(path.join(projDir, file.name))
+      if (parsed) sessions.push(parsed)
+    }
+  }
+
+  return sessions
+}

package/src/server/claude-session-types.ts

@@ -0,0 +1,61 @@
+// src/server/claude-session-types.ts
+
+export interface ClaudeSessionRecordBase {
+  type: string
+  uuid?: string
+  parentUuid?: string | null
+  sessionId?: string
+  timestamp?: string
+  cwd?: string
+  version?: string
+}
+
+export interface ClaudeSessionUserRecord extends ClaudeSessionRecordBase {
+  type: "user"
+  message: {
+    role: "user"
+    content: string | Array<
+      | { type: "text"; text: string }
+      | { type: "tool_result"; tool_use_id: string; content?: unknown; is_error?: boolean }
+    >
+  }
+}
+
+export interface ClaudeSessionAssistantRecord extends ClaudeSessionRecordBase {
+  type: "assistant"
+  message: {
+    role: "assistant"
+    id?: string
+    content: Array<
+      | { type: "text"; text: string }
+      | { type: "tool_use"; id: string; name: string; input: Record<string, unknown> }
+    >
+  }
+}
+
+export interface ClaudeSessionSummaryRecord extends ClaudeSessionRecordBase {
+  type: "summary"
+  summary?: string
+}
+
+export interface ClaudeSessionSystemRecord extends ClaudeSessionRecordBase {
+  type: "system"
+  content?: string
+}
+
+export type ClaudeSessionRecord =
+  | ClaudeSessionUserRecord
+  | ClaudeSessionAssistantRecord
+  | ClaudeSessionSummaryRecord
+  | ClaudeSessionSystemRecord
+  | ClaudeSessionRecordBase
+
+export interface ParsedClaudeSession {
+  sessionId: string
+  filePath: string
+  cwd: string
+  firstTimestamp: number
+  lastTimestamp: number
+  records: ClaudeSessionRecord[]
+  sourceHash: string
+}