@alexzeitler/session-md 0.5.0

package/src/import/loader.ts

@@ -0,0 +1,86 @@
+import { join } from "path";
+import type { SessionEntry } from "./types.ts";
+
+const cache = new Map<string, string>();
+let worker: Worker | null = null;
+let pendingCallbacks = new Map<
+  string,
+  { resolve: (md: string) => void; reject: (err: Error) => void }
+>();
+
+function getWorker(): Worker {
+  if (!worker) {
+    worker = new Worker(join(import.meta.dir, "parse-worker.ts"));
+    worker.onmessage = (event: MessageEvent) => {
+      const { id, md, error } = event.data;
+      const cb = pendingCallbacks.get(id);
+      if (!cb) return;
+      pendingCallbacks.delete(id);
+
+      if (error) {
+        cb.reject(new Error(error));
+      } else {
+        cache.set(id, md);
+        cb.resolve(md);
+      }
+    };
+  }
+  return worker;
+}
+
+/**
+ * Loads markdown for a session entry asynchronously.
+ * Cached results return immediately. Heavy parsing runs in a worker thread.
+ */
+export function loadSessionMarkdownAsync(
+  entry: SessionEntry,
+): Promise<string> {
+  // Pre-generated (memorizer, claude-export)
+  if (entry.md) return Promise.resolve(entry.md);
+
+  // Cached
+  const cached = cache.get(entry.meta.id);
+  if (cached) return Promise.resolve(cached);
+
+  // Cancel any pending load for the same id
+  const existing = pendingCallbacks.get(entry.meta.id);
+  if (existing) {
+    existing.reject(new Error("cancelled"));
+    pendingCallbacks.delete(entry.meta.id);
+  }
+
+  return new Promise((resolve, reject) => {
+    pendingCallbacks.set(entry.meta.id, { resolve, reject });
+    getWorker().postMessage({
+      id: entry.meta.id,
+      source: entry.meta.source,
+      sourcePath: entry.sourcePath,
+      sessionId: entry.meta.id,
+    });
+  });
+}
+
+/** Synchronous cache-only check (for copy-to-target) */
+export function loadSessionMarkdownSync(entry: SessionEntry): string {
+  if (entry.md) return entry.md;
+  const cached = cache.get(entry.meta.id);
+  if (cached) return cached;
+
+  // Fallback: import synchronously (for copy operations)
+  if (entry.meta.source === "claude-code") {
+    const { claudeCodeSessionToMd } = require("./claude-code-to-md.ts");
+    const md = claudeCodeSessionToMd(entry.sourcePath);
+    cache.set(entry.meta.id, md);
+    return md;
+  }
+  if (entry.meta.source === "opencode") {
+    const { dirname } = require("path");
+    const { opencodeSessionToMd } = require("./opencode-to-md.ts");
+    const storagePath = dirname(dirname(dirname(entry.sourcePath)));
+    const md = opencodeSessionToMd(storagePath, entry.meta.id);
+    cache.set(entry.meta.id, md);
+    return md;
+  }
+
+  return `# ${entry.meta.title}\n\n*Content not available*`;
+}

package/src/import/memorizer-to-md.ts

@@ -0,0 +1,117 @@
+import { join } from "path";
+import {
+  type SessionEntry,
+  slugify,
+} from "./types.ts";
+
+interface Workspace {
+  id: string;
+  name: string;
+}
+
+interface Project {
+  id: string;
+  name: string;
+  workspaceName: string;
+}
+
+interface Memory {
+  id: string;
+  title: string;
+  text: string;
+  type: string;
+  tags: string[];
+  confidence: number;
+  createdAt: string;
+  updatedAt: string;
+}
+
+async function fetchJson<T>(url: string): Promise<T> {
+  const res = await fetch(url);
+  if (!res.ok) throw new Error(`HTTP ${res.status}: ${url}`);
+  return res.json() as Promise<T>;
+}
+
+async function fetchAllMemories(
+  baseUrl: string,
+  projectId: string,
+): Promise<Memory[]> {
+  const all: Memory[] = [];
+  let page = 1;
+  const pageSize = 100;
+
+  while (true) {
+    const url = `${baseUrl}/api/memory?projectId=${projectId}&page=${page}&pageSize=${pageSize}`;
+    const res = await fetchJson<{ memories: Memory[] }>(url);
+    all.push(...res.memories);
+    if (res.memories.length < pageSize) break;
+    page++;
+  }
+
+  return all;
+}
+
+/**
+ * Fetches all memories from Memorizer API.
+ * Returns SessionEntry[] with pre-generated markdown (md field set).
+ */
+export async function scanMemorizerMemories(
+  baseUrl: string,
+): Promise<SessionEntry[]> {
+  const entries: SessionEntry[] = [];
+
+  const { workspaces } = await fetchJson<{ workspaces: Workspace[] }>(
+    `${baseUrl}/api/workspace`,
+  );
+
+  for (const ws of workspaces) {
+    const { projects } = await fetchJson<{ projects: Project[] }>(
+      `${baseUrl}/api/project?workspaceId=${ws.id}`,
+    );
+
+    for (const proj of projects) {
+      const memories = await fetchAllMemories(baseUrl, proj.id);
+
+      for (const mem of memories) {
+        const tags = mem.tags.length > 0 ? `[${mem.tags.join(", ")}]` : "[]";
+
+        const frontmatter = [
+          "---",
+          `title: "${mem.title.replace(/"/g, '\\"')}"`,
+          `id: ${mem.id}`,
+          `source: memorizer`,
+          `workspace: "${ws.name.replace(/"/g, '\\"')}"`,
+          `project: "${proj.name.replace(/"/g, '\\"')}"`,
+          `type: ${mem.type}`,
+          `tags: ${tags}`,
+          `confidence: ${mem.confidence}`,
+          `created_at: ${mem.createdAt}`,
+          `updated_at: ${mem.updatedAt}`,
+          "---",
+        ].join("\n");
+
+        const md = `${frontmatter}\n\n# ${mem.title}\n\n${mem.text}`;
+        const wsSlug = slugify(ws.name);
+        const projSlug = slugify(proj.name);
+        const titleSlug = slugify(mem.title);
+
+        entries.push({
+          filename: join(wsSlug, projSlug, `${titleSlug}.md`),
+          sourcePath: `${baseUrl}/api/memory/${mem.id}`,
+          contentHash: mem.updatedAt,
+          md,
+          meta: {
+            title: mem.title,
+            id: mem.id,
+            source: "memorizer",
+            project: `${ws.name}/${proj.name}`,
+            created_at: mem.createdAt,
+            updated_at: mem.updatedAt,
+          },
+        });
+      }
+    }
+  }
+
+  return entries;
+}

package/src/import/opencode-to-md.ts

@@ -0,0 +1,176 @@
+import { join } from "path";
+import { readdirSync, existsSync, readFileSync, statSync } from "fs";
+import {
+  type SessionEntry,
+  type SessionMeta,
+  buildFrontmatter,
+  formatDate,
+  truncateTitle,
+} from "./types.ts";
+
+interface OcSession {
+  id: string;
+  version: string;
+  title: string;
+  time: { created: number; updated: number };
+}
+
+interface OcMessage {
+  id: string;
+  sessionID: string;
+  role: string;
+  time: { created: number; completed?: number };
+  parentID?: string;
+  modelID?: string;
+}
+
+interface OcPart {
+  id: string;
+  sessionID: string;
+  messageID: string;
+  type: string;
+  text?: string;
+  tool?: string;
+  state?: {
+    status: string;
+    input?: Record<string, unknown>;
+    output?: string;
+    title?: string;
+  };
+}
+
+function readJson<T>(path: string): T | null {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Fast scan: only reads session metadata files, no message/part parsing.
+ */
+export function scanOpencodeSessions(
+  storagePath: string,
+): SessionEntry[] {
+  if (!existsSync(storagePath)) return [];
+
+  const sessionDir = join(storagePath, "session");
+  if (!existsSync(sessionDir)) return [];
+
+  const entries: SessionEntry[] = [];
+
+  for (const projHash of readdirSync(sessionDir)) {
+    const projDir = join(sessionDir, projHash);
+    let files: string[];
+    try {
+      files = readdirSync(projDir).filter((f) => f.endsWith(".json"));
+    } catch {
+      continue;
+    }
+
+    for (const file of files) {
+      const ses = readJson<OcSession>(join(projDir, file));
+      if (!ses) continue;
+
+      const filePath = join(projDir, file);
+      const date = formatDate(new Date(ses.time.created));
+      const shortId = ses.id.replace(/^ses_/, "").slice(0, 8);
+      const fileStat = statSync(filePath);
+
+      entries.push({
+        filename: `${date}-${shortId}.md`,
+        sourcePath: filePath,
+        contentHash: String(fileStat.size),
+        meta: {
+          title: ses.title || `Session ${shortId}`,
+          id: ses.id,
+          source: "opencode",
+          created_at: new Date(ses.time.created).toISOString(),
+          updated_at: new Date(ses.time.updated).toISOString(),
+        },
+      });
+    }
+  }
+
+  return entries;
+}
+
+/**
+ * Full parse: reads session + all messages + parts and generates markdown.
+ */
+export function opencodeSessionToMd(
+  storagePath: string,
+  sessionId: string,
+): string {
+  const sessionDir = join(storagePath, "session");
+  if (!existsSync(sessionDir)) return "";
+
+  let session: OcSession | null = null;
+  for (const projHash of readdirSync(sessionDir)) {
+    const sesPath = join(sessionDir, projHash, `${sessionId}.json`);
+    if (existsSync(sesPath)) {
+      session = readJson<OcSession>(sesPath);
+      break;
+    }
+  }
+  if (!session) return "";
+
+  const msgDir = join(storagePath, "message", sessionId);
+  if (!existsSync(msgDir)) return "";
+
+  const msgFiles = readdirSync(msgDir).filter((f) => f.endsWith(".json")).sort();
+  const messages: OcMessage[] = [];
+  for (const f of msgFiles) {
+    const msg = readJson<OcMessage>(join(msgDir, f));
+    if (msg) messages.push(msg);
+  }
+
+  messages.sort((a, b) => a.time.created - b.time.created);
+
+  const mdSections: string[] = [];
+  for (const msg of messages) {
+    const partDir = join(storagePath, "part", msg.id);
+    if (!existsSync(partDir)) continue;
+
+    const partFiles = readdirSync(partDir).filter((f) => f.endsWith(".json")).sort();
+    const parts: OcPart[] = [];
+    for (const f of partFiles) {
+      const part = readJson<OcPart>(join(partDir, f));
+      if (part) parts.push(part);
+    }
+
+    const textParts: string[] = [];
+    for (const part of parts) {
+      if (part.type === "text" && part.text) {
+        textParts.push(part.text);
+      } else if (part.type === "tool" && part.tool && part.state) {
+        const inputStr = part.state.input
+          ? JSON.stringify(part.state.input, null, 2)
+          : "";
+        textParts.push(
+          `> **Tool**: ${part.tool}\n> \`\`\`\n> ${inputStr}\n> \`\`\``,
+        );
+      }
+    }
+
+    if (textParts.length === 0) continue;
+    const role = msg.role === "user" ? "Human" : "Claude";
+    mdSections.push(`## ${role}\n\n${textParts.join("\n\n")}`);
+  }
+
+  const title = session.title || `Session ${sessionId.slice(0, 8)}`;
+  const created = new Date(session.time.created);
+  const updated = new Date(session.time.updated);
+
+  const meta: SessionMeta = {
+    title: truncateTitle(title),
+    id: sessionId,
+    source: "opencode",
+    created_at: created.toISOString(),
+    updated_at: updated.toISOString(),
+  };
+
+  const frontmatter = buildFrontmatter(meta);
+  return `${frontmatter}\n\n# ${meta.title}\n\n${mdSections.join("\n\n")}`;
+}

package/src/import/parse-worker.ts

@@ -0,0 +1,28 @@
+/// Worker thread: parses session files off the main thread.
+
+import { claudeCodeSessionToMd } from "./claude-code-to-md.ts";
+import { opencodeSessionToMd } from "./opencode-to-md.ts";
+import { dirname } from "path";
+
+declare var self: Worker;
+
+self.onmessage = (event: MessageEvent) => {
+  const { id, source, sourcePath, sessionId } = event.data;
+
+  try {
+    let md: string;
+
+    if (source === "claude-code") {
+      md = claudeCodeSessionToMd(sourcePath);
+    } else if (source === "opencode") {
+      const storagePath = dirname(dirname(dirname(sourcePath)));
+      md = opencodeSessionToMd(storagePath, sessionId);
+    } else {
+      md = `# Untitled\n\n*Content not available*`;
+    }
+
+    self.postMessage({ id, md, error: null });
+  } catch (err) {
+    self.postMessage({ id, md: null, error: String(err) });
+  }
+};

package/src/import/types.ts

@@ -0,0 +1,56 @@
+export type SourceType = "claude-code" | "claude-export" | "opencode" | "memorizer";
+
+export interface SessionEntry {
+  /** Display filename (e.g. 2026-03-13-abc12345.md) */
+  filename: string;
+  /** Session metadata (collected without reading file content) */
+  meta: SessionMeta;
+  /** Absolute path to the original source file (for lazy loading) */
+  sourcePath: string;
+  /** Pre-generated markdown (only set for memorizer/claude-export, null for lazy sources) */
+  md?: string;
+  /** Hash for search index invalidation (file size, updated_at, etc.) */
+  contentHash: string;
+}
+
+export interface SessionMeta {
+  title: string;
+  id: string;
+  source: SourceType;
+  project?: string;
+  created_at: string;
+  updated_at: string;
+}
+
+export function buildFrontmatter(meta: SessionMeta): string {
+  const lines = [
+    "---",
+    `title: "${meta.title.replace(/"/g, '\\"')}"`,
+    `id: ${meta.id}`,
+    `source: ${meta.source}`,
+  ];
+  if (meta.project) {
+    lines.push(`project: "${meta.project.replace(/"/g, '\\"')}"`);
+  }
+  lines.push(`created_at: ${meta.created_at}`);
+  lines.push(`updated_at: ${meta.updated_at}`);
+  lines.push("---");
+  return lines.join("\n");
+}
+
+export function slugify(text: string): string {
+  return text
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, "-")
+    .replace(/^-|-$/g, "")
+    .slice(0, 80);
+}
+
+export function formatDate(date: Date): string {
+  return date.toISOString().split("T")[0]!;
+}
+
+export function truncateTitle(text: string, maxLen = 80): string {
+  if (text.length <= maxLen) return text;
+  return text.slice(0, maxLen).trimEnd() + "…";
+}