nlm-memory 0.4.2 → 0.5.1

package/src/core/adapters/opencode.ts

@@ -1,281 +0,0 @@
-/**
- * OpenCode adapter.
- *
- * Reads the OpenCode SQLite database at:
- *   macOS: ~/Library/Application Support/opencode/opencode.db
- *   Linux: $XDG_DATA_HOME/opencode/opencode.db (default ~/.local/share/opencode/opencode.db)
- *
- * Unlike the JSONL-based adapters, OpenCode stores all sessions and messages
- * in a single SQLite file. `discover()` queries the sessions table and returns
- * session IDs (not file paths). `parseSession()` treats its string argument as
- * a session ID and reconstructs a SessionChunk from the messages and parts tables.
- *
- * Part types extracted:
- *   - text  (non-ignored): the conversational prose
- *   - tool  : summarized as [tool: <name>]
- *   All other part types (reasoning, step-start/finish, snapshot, patch,
- *   compaction, agent, retry, subtask) are structural and skipped.
- *
- * Format reference: verified against sst/opencode migration
- * 20260127222353_familiar_lady_ursula and session.sql.ts, 2026-05-28.
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import Database from "better-sqlite3";
-import type {
-  DetectionResult,
-  DiscoverOptions,
-  SessionChunk,
-  TranscriptAdapter,
-} from "@ports/transcript-adapter.js";
-import { durationMinutes, normalizeTimestamp } from "./common.js";
-
-const TOOL_OUTPUT_PREVIEW_CHARS = 240;
-
-export interface OpenCodeAdapterOptions {
-  readonly dbPath?: string;
-}
-
-interface Turn {
-  readonly role: "user" | "assistant";
-  readonly text: string;
-  readonly timestamp: string;
-}
-
-interface SessionRow {
-  readonly id: string;
-  readonly directory: string;
-  readonly title: string;
-  readonly time_created: number;
-  readonly time_updated: number;
-}
-
-interface MessageRow {
-  readonly id: string;
-  readonly time_created: number;
-  readonly data: string;
-}
-
-interface PartRow {
-  readonly message_id: string;
-  readonly time_created: number;
-  readonly data: string;
-}
-
-interface MessageInfo {
-  readonly role: "user" | "assistant";
-}
-
-interface TextPartData {
-  readonly type: "text";
-  readonly text: string;
-  readonly ignored?: boolean;
-}
-
-interface ToolPartData {
-  readonly type: "tool";
-  readonly tool: string;
-  readonly state?: Record<string, unknown>;
-}
-
-type PartData = TextPartData | ToolPartData | { readonly type: string };
-
-export function defaultDbPath(): string {
-  if (process.env["OPENCODE_DB_PATH"]) return process.env["OPENCODE_DB_PATH"];
-  if (process.platform === "darwin") {
-    return join(homedir(), "Library", "Application Support", "opencode", "opencode.db");
-  }
-  const xdg = process.env["XDG_DATA_HOME"] ?? join(homedir(), ".local", "share");
-  return join(xdg, "opencode", "opencode.db");
-}
-
-function readGitBranch(directory: string): string {
-  try {
-    const head = readFileSync(join(directory, ".git", "HEAD"), "utf8").trim();
-    const match = /^ref: refs\/heads\/(.+)$/.exec(head);
-    return match ? (match[1] ?? "") : "";
-  } catch {
-    return "";
-  }
-}
-
-function extractTurns(messages: MessageRow[], partsByMessage: Map<string, PartData[]>): Turn[] {
-  const turns: Turn[] = [];
-  for (const msg of messages) {
-    let info: MessageInfo;
-    try {
-      info = JSON.parse(msg.data) as MessageInfo;
-    } catch {
-      continue;
-    }
-    if (info.role !== "user" && info.role !== "assistant") continue;
-
-    const parts = partsByMessage.get(msg.id) ?? [];
-    const segments: string[] = [];
-
-    for (const p of parts) {
-      if (p.type === "text") {
-        const tp = p as TextPartData;
-        if (!tp.ignored && tp.text) segments.push(tp.text);
-      } else if (p.type === "tool") {
-        const tp = p as ToolPartData;
-        const output = extractToolOutput(tp);
-        segments.push(output ? `[tool: ${tp.tool}] ${output}` : `[tool: ${tp.tool}]`);
-      }
-    }
-
-    const text = segments.join("\n").trim();
-    if (!text) continue;
-
-    turns.push({ role: info.role, text, timestamp: normalizeTimestamp(msg.time_created) });
-  }
-  return turns;
-}
-
-function extractToolOutput(part: ToolPartData): string {
-  const state = part.state;
-  if (!state) return "";
-  const output =
-    (state["output"] as string | undefined) ??
-    (state["result"] as string | undefined) ??
-    "";
-  if (typeof output !== "string" || !output) return "";
-  const preview = output.slice(0, TOOL_OUTPUT_PREVIEW_CHARS);
-  return output.length > TOOL_OUTPUT_PREVIEW_CHARS ? `${preview}…` : preview;
-}
-
-function provisionalLabel(turns: ReadonlyArray<Turn>): string {
-  for (const t of turns) {
-    if (t.role !== "user") continue;
-    const first = t.text.split("\n", 1)[0]?.trim();
-    if (first) return first.slice(0, 80);
-  }
-  return "Untitled session";
-}
-
-export class OpenCodeAdapter implements TranscriptAdapter {
-  readonly name = "opencode";
-  readonly runtimeVersion = "opencode/1.0";
-  readonly transcriptKind = "opencode-sqlite";
-
-  private readonly dbPath: string;
-
-  constructor(opts: OpenCodeAdapterOptions = {}) {
-    this.dbPath = opts.dbPath ?? defaultDbPath();
-  }
-
-  detect(): DetectionResult {
-    if (existsSync(this.dbPath)) {
-      return { adapterName: this.name, enabled: true, path: this.dbPath, hint: null };
-    }
-    return { adapterName: this.name, enabled: false, path: null, hint: "opencode.db not found" };
-  }
-
-  async discover(options?: DiscoverOptions): Promise<ReadonlyArray<string>> {
-    if (!existsSync(this.dbPath)) return [];
-    let db: Database.Database | undefined;
-    try {
-      db = new Database(this.dbPath, { readonly: true });
-      let rows: { id: string }[];
-      if (options?.since) {
-        const sinceMs = options.since.getTime();
-        rows = db
-          .prepare<[number], { id: string }>(
-            `SELECT id FROM session WHERE time_archived IS NULL AND time_updated >= ?`,
-          )
-          .all(sinceMs);
-      } else {
-        rows = db
-          .prepare<[], { id: string }>(
-            `SELECT id FROM session WHERE time_archived IS NULL`,
-          )
-          .all();
-      }
-      return rows.map((r) => r.id);
-    } catch {
-      return [];
-    } finally {
-      db?.close();
-    }
-  }
-
-  async parseSession(sessionId: string): Promise<SessionChunk | null> {
-    if (!existsSync(this.dbPath)) return null;
-    let db: Database.Database | undefined;
-    try {
-      db = new Database(this.dbPath, { readonly: true });
-
-      const session = db
-        .prepare<[string], SessionRow>(
-          `SELECT id, directory, title, time_created, time_updated
-           FROM session WHERE id = ?`,
-        )
-        .get(sessionId);
-      if (!session) return null;
-
-      const messages = db
-        .prepare<[string], MessageRow>(
-          `SELECT id, time_created, data FROM message
-           WHERE session_id = ? ORDER BY time_created ASC`,
-        )
-        .all(sessionId);
-
-      const partRows = db
-        .prepare<[string], PartRow>(
-          `SELECT message_id, time_created, data FROM part
-           WHERE session_id = ? ORDER BY time_created ASC`,
-        )
-        .all(sessionId);
-
-      const partsByMessage = new Map<string, PartData[]>();
-      for (const row of partRows) {
-        let data: PartData;
-        try {
-          data = JSON.parse(row.data) as PartData;
-        } catch {
-          continue;
-        }
-        const bucket = partsByMessage.get(row.message_id);
-        if (bucket) {
-          bucket.push(data);
-        } else {
-          partsByMessage.set(row.message_id, [data]);
-        }
-      }
-
-      const turns = extractTurns(messages, partsByMessage);
-      if (turns.length === 0) return null;
-
-      const startedAt = normalizeTimestamp(session.time_created);
-      const endedAt = normalizeTimestamp(session.time_updated);
-      const transcript = turns.map((t) => `${t.role}: ${t.text}`).join("\n\n");
-
-      const label =
-        session.title && session.title !== "New session"
-          ? session.title.slice(0, 80)
-          : provisionalLabel(turns);
-
-      return {
-        id: `oc_${sessionId}`,
-        runtime: this.runtimeVersion,
-        runtimeSessionId: sessionId,
-        sourcePath: `${this.dbPath}::${sessionId}`,
-        startedAt,
-        endedAt,
-        durationMin: durationMinutes(startedAt, endedAt),
-        turnCount: turns.length,
-        byteRange: [0, Buffer.byteLength(transcript, "utf8")],
-        projectDir: session.directory,
-        gitBranch: readGitBranch(session.directory),
-        text: transcript,
-        label,
-      };
-    } catch {
-      return null;
-    } finally {
-      db?.close();
-    }
-  }
-}

package/src/core/adapters/pi.ts

@@ -1,264 +0,0 @@
-/**
- * Pi adapter.
- *
- * Reads ~/.pi/agent/sessions/<cwd-slug>/<timestamp>_<uuid>.jsonl. Pi writes
- * session files even when a run aborts — those still ingest, but the adapter
- * flags them via the `gitBranch: "aborted"` sentinel (SessionChunk has no
- * status field; storage layer decodes the sentinel later).
- *
- * File shape (v3, confirmed 2026-05-18): one JSON object per line. Five
- * event types: session, model_change, thinking_level_change, message,
- * custom_message. Only `message` produces turns; the rest are configuration
- * or extension-injected (custom_message must be excluded).
- *
- * Discovery is recursive (`<sessions>/<cwd-slug>/<file>.jsonl`).
- * $PI_SESSIONS_PATH overrides the default path.
- */
-
-import { promises as fs, existsSync, statSync } from "node:fs";
-import { extname, join } from "node:path";
-import { homedir } from "node:os";
-import type {
-  DetectionResult,
-  DiscoverOptions,
-  SessionChunk,
-  TranscriptAdapter,
-} from "@ports/transcript-adapter.js";
-import {
-  durationMinutes,
-  normalizeTimestamp,
-  safeSessionId,
-} from "./common.js";
-
-const TOOL_RESULT_PREVIEW_CHARS = 240;
-
-export interface PiAdapterOptions {
-  readonly sessionsPath?: string;
-  readonly idleMinutes?: number;
-}
-
-interface Turn {
-  readonly role: "user" | "assistant";
-  readonly text: string;
-  readonly timestamp: string;
-}
-
-function defaultSessionsPath(): string {
-  return (
-    process.env["PI_SESSIONS_PATH"] ??
-    join(homedir(), ".pi", "agent", "sessions")
-  );
-}
-
-export class PiAdapter implements TranscriptAdapter {
-  readonly name = "pi";
-  readonly runtimeVersion = "pi/1.0";
-  readonly transcriptKind = "pi-jsonl";
-
-  private readonly sessionsPath: string;
-  readonly idleMinutes: number;
-
-  constructor(opts: PiAdapterOptions = {}) {
-    this.sessionsPath = opts.sessionsPath ?? defaultSessionsPath();
-    this.idleMinutes = opts.idleMinutes ?? 15;
-  }
-
-  detect(): DetectionResult {
-    const p = defaultSessionsPath();
-    if (existsSync(p) && statSync(p).isDirectory()) {
-      return { adapterName: this.name, enabled: true, path: p, hint: null };
-    }
-    return {
-      adapterName: this.name,
-      enabled: false,
-      path: null,
-      hint: "Pi not detected — ~/.pi/agent/sessions/ missing.",
-    };
-  }
-
-  async discover(options: DiscoverOptions = {}): Promise<ReadonlyArray<string>> {
-    if (!existsSync(this.sessionsPath)) return [];
-
-    const found: { mtime: number; path: string }[] = [];
-    await walk(this.sessionsPath, async (full, st) => {
-      if (st.size === 0) return;
-      if (extname(full) !== ".jsonl") return;
-      if (options.since && st.mtime < options.since) return;
-      found.push({ mtime: st.mtimeMs, path: full });
-    });
-    found.sort((a, b) => a.mtime - b.mtime);
-    return found.map((f) => f.path);
-  }
-
-  async parseSession(path: string): Promise<SessionChunk | null> {
-    let raw: string;
-    try {
-      raw = await fs.readFile(path, "utf8");
-    } catch {
-      return null;
-    }
-
-    const turns: Turn[] = [];
-    let sessionId = "";
-    let projectDir = "";
-    let startedAt = "";
-    let endedAt = "";
-    let totalBytes = 0;
-    let allAssistantErrors = true;
-
-    for (const line of raw.split("\n")) {
-      totalBytes += Buffer.byteLength(line, "utf8") + 1;
-      const trimmed = line.trim();
-      if (!trimmed) continue;
-
-      let evt: Record<string, unknown>;
-      try {
-        evt = JSON.parse(trimmed) as Record<string, unknown>;
-      } catch {
-        continue;
-      }
-
-      const evtType = evt["type"];
-
-      if (evtType === "session") {
-        if (typeof evt["id"] === "string") sessionId = evt["id"];
-        if (typeof evt["cwd"] === "string") projectDir = evt["cwd"];
-        continue;
-      }
-      if (
-        evtType === "model_change" ||
-        evtType === "thinking_level_change" ||
-        evtType === "custom_message"
-      ) {
-        continue;
-      }
-      if (evtType !== "message") continue;
-
-      const msg = isRecord(evt["message"]) ? (evt["message"] as Record<string, unknown>) : {};
-      const role = msg["role"];
-      if (role !== "user" && role !== "assistant") continue;
-
-      const innerTs = msg["timestamp"];
-      const outerTs = evt["timestamp"];
-      const ts = innerTs
-        ? normalizeTimestamp(innerTs)
-        : normalizeTimestamp(outerTs);
-      if (ts) {
-        if (!startedAt) startedAt = ts;
-        endedAt = ts;
-      }
-
-      const text = extractPiText(msg["content"]);
-
-      if (role === "assistant") {
-        const stop = typeof msg["stopReason"] === "string" ? msg["stopReason"] : "";
-        if (stop !== "error") allAssistantErrors = false;
-        if (!text.trim()) continue; // error turns have empty content
-      } else if (!text.trim()) {
-        continue;
-      }
-
-      turns.push({ role, text, timestamp: ts });
-    }
-
-    if (turns.length === 0) return null;
-
-    const hasUser = turns.some((t) => t.role === "user");
-    const hasSuccessfulAssistant = turns.some((t) => t.role === "assistant");
-    const isAborted =
-      hasUser && (!hasSuccessfulAssistant || allAssistantErrors);
-
-    const transcript = turns.map((t) => `[${t.role}] ${t.text}`).join("\n\n");
-    const duration = durationMinutes(startedAt, endedAt);
-    const label = provisionalLabel(turns);
-    const rawId = sessionId || path.split("/").pop()!.replace(".jsonl", "");
-
-    return {
-      id: safeSessionId("pi", rawId),
-      runtime: this.runtimeVersion,
-      runtimeSessionId: rawId,
-      sourcePath: path,
-      startedAt,
-      endedAt,
-      durationMin: duration,
-      turnCount: turns.length,
-      byteRange: [0, totalBytes],
-      projectDir,
-      gitBranch: isAborted ? "aborted" : "",
-      text: transcript,
-      label,
-    };
-  }
-}
-
-// ── helpers ──────────────────────────────────────────────────────────────
-
-function isRecord(v: unknown): v is Record<string, unknown> {
-  return !!v && typeof v === "object" && !Array.isArray(v);
-}
-
-async function walk(
-  dir: string,
-  onFile: (path: string, st: import("node:fs").Stats) => Promise<void>,
-): Promise<void> {
-  let entries;
-  try {
-    entries = await fs.readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const ent of entries) {
-    const full = join(dir, ent.name);
-    if (ent.isDirectory()) {
-      await walk(full, onFile);
-    } else if (ent.isFile()) {
-      try {
-        const st = await fs.stat(full);
-        await onFile(full, st);
-      } catch {
-        continue;
-      }
-    }
-  }
-}
-
-function extractPiText(content: unknown): string {
-  if (typeof content === "string") return content.trim();
-  if (!Array.isArray(content)) return "";
-
-  const parts: string[] = [];
-  for (const block of content) {
-    if (!isRecord(block)) continue;
-    const btype = block["type"];
-    if (btype === "text") {
-      const t = block["text"];
-      if (typeof t === "string" && t.trim()) parts.push(t.trim());
-    } else if (btype === "tool_use") {
-      const name = typeof block["name"] === "string" ? block["name"] : "tool";
-      parts.push(`[tool_use: ${name}]`);
-    } else if (btype === "tool_result") {
-      let res = block["content"];
-      if (Array.isArray(res)) {
-        res = res
-          .filter(isRecord)
-          .map((b) => (typeof b["text"] === "string" ? (b["text"] as string) : ""))
-          .join("\n");
-      }
-      if (typeof res === "string" && res) {
-        const preview = res.slice(0, TOOL_RESULT_PREVIEW_CHARS);
-        const ellipsis = res.length > TOOL_RESULT_PREVIEW_CHARS ? "..." : "";
-        parts.push(`[tool_result: ${preview}${ellipsis}]`);
-      }
-    }
-  }
-  return parts.filter((p) => p).join("\n");
-}
-
-function provisionalLabel(turns: ReadonlyArray<Turn>): string {
-  for (const t of turns) {
-    if (t.role !== "user") continue;
-    const firstLine = t.text.split("\n", 1)[0]?.trim();
-    if (firstLine) return firstLine.slice(0, 80);
-  }
-  return "Untitled session";
-}