nlm-memory 0.4.2 → 0.5.1

package/src/core/actions/actions-log.ts

@@ -1,118 +0,0 @@
-/**
- * actions-log — append-only event source for every interactive change.
- *
- * The actions table is canonical: dismiss/snooze/retire/label/merge are
- * all rows here, never destructive mutations elsewhere. Dataset projection
- * (build-dataset.ts) reads this table to overlay user-driven state on top
- * of the persisted store. Ports server.py's _write_action + undo flow.
- */
-
-import type Database from "better-sqlite3";
-
-export interface ActionInput {
-  readonly kind: string;
-  readonly subjectType: string;
-  readonly subjectId: string;
-  readonly payload?: Record<string, unknown>;
-  readonly actor?: string;
-  readonly runtime?: string;
-}
-
-export interface ActionRow {
-  readonly id: string;
-  readonly timestamp: string;
-  readonly kind: string;
-  readonly subject_type: string;
-  readonly subject_id: string;
-  readonly payload: Record<string, unknown> | null;
-  readonly actor: string;
-  readonly runtime: string | null;
-  readonly reverted_by: string | null;
-}
-
-function makeActionId(): string {
-  const ts = new Date().toISOString().replace(/[:.]/g, "-");
-  const rand = Math.random().toString(16).slice(2, 10);
-  return `act_${ts}_${rand}`;
-}
-
-export function writeAction(db: Database.Database, input: ActionInput): string {
-  const id = makeActionId();
-  const payload = input.payload ? JSON.stringify(input.payload) : null;
-  db.prepare(`
-    INSERT INTO actions (id, timestamp, kind, subject_type, subject_id, payload, actor, runtime)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(
-    id,
-    new Date().toISOString(),
-    input.kind,
-    input.subjectType,
-    input.subjectId,
-    payload,
-    input.actor ?? "user",
-    input.runtime ?? "api",
-  );
-  return id;
-}
-
-export function writeActionsBatch(db: Database.Database, inputs: ReadonlyArray<ActionInput>): string[] {
-  const txn = db.transaction((rows: ReadonlyArray<ActionInput>) => rows.map((r) => writeAction(db, r)));
-  return txn(inputs);
-}
-
-export interface UndoResult {
-  readonly undoId: string;
-  readonly originalKind: string;
-}
-
-export function undoAction(db: Database.Database, actionId: string): UndoResult | null {
-  const target = db
-    .prepare<[string], { id: string; kind: string; subject_type: string; subject_id: string }>(
-      "SELECT id, kind, subject_type, subject_id FROM actions WHERE id = ? AND reverted_by IS NULL",
-    )
-    .get(actionId);
-  if (!target) return null;
-
-  const undoId = makeActionId();
-  const undoPayload = JSON.stringify({
-    undone_kind: target.kind,
-    undone_subject: `${target.subject_type}:${target.subject_id}`,
-  });
-  const txn = db.transaction(() => {
-    db.prepare(`
-      INSERT INTO actions (id, timestamp, kind, subject_type, subject_id, payload, actor, runtime)
-      VALUES (?, ?, 'undo', 'action', ?, ?, 'user', 'api')
-    `).run(undoId, new Date().toISOString(), actionId, undoPayload);
-    db.prepare("UPDATE actions SET reverted_by = ? WHERE id = ?").run(undoId, actionId);
-  });
-  txn();
-  return { undoId, originalKind: target.kind };
-}
-
-export function listActions(
-  db: Database.Database,
-  opts: { limit?: number; subjectId?: string; kind?: string } = {},
-): ActionRow[] {
-  const limit = opts.limit ?? 100;
-  const where: string[] = [];
-  const params: unknown[] = [];
-  if (opts.subjectId) {
-    where.push("subject_id = ?");
-    params.push(opts.subjectId);
-  }
-  if (opts.kind) {
-    where.push("kind = ?");
-    params.push(opts.kind);
-  }
-  const whereSql = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
-  const sql = `
-    SELECT id, timestamp, kind, subject_type, subject_id, payload, actor, runtime, reverted_by
-    FROM actions
-    ${whereSql}
-    ORDER BY timestamp DESC
-    LIMIT ?
-  `;
-  params.push(limit);
-  const rows = db.prepare<unknown[], ActionRow & { payload: string | null }>(sql).all(...params);
-  return rows.map((r) => ({ ...r, payload: r.payload ? (JSON.parse(r.payload) as Record<string, unknown>) : null }));
-}

package/src/core/actions/overlay.ts

@@ -1,117 +0,0 @@
-/**
- * Action overlay loader. Reads the canonical action log and projects active
- * user-driven state (dismissed alerts, retired entities, snoozes, label
- * overrides, resolved/promoted open questions) so consumers can apply them
- * at read time without mutating the underlying store.
- *
- * Shared by buildDataset (UI projection) and SqliteSessionStore (recall
- * path), so the same overlay drives both surfaces. Append-only — every
- * mutation lives as a row in `actions`.
- */
-
-import type Database from "better-sqlite3";
-
-export interface ActionOverlay {
-  readonly dismissedAlerts: Set<string>;
-  readonly snoozedAlerts: Map<string, string>; // alert id → snoozed_until ISO
-  readonly retiredEntities: Set<string>;
-  readonly snoozedEntities: Map<string, string>;
-  readonly labeledEntities: Map<string, string>;
-  /** open-question ids resolved without becoming decisions */
-  readonly resolvedOpens: Set<string>;
-  /** open-question id → resolution text (becomes a decision at projection time) */
-  readonly promotedOpens: Map<string, string>;
-}
-
-interface ActionRow {
-  kind: string;
-  subject_type: string;
-  subject_id: string;
-  payload: string | null;
-}
-
-export const EMPTY_OVERLAY: ActionOverlay = {
-  dismissedAlerts: new Set(),
-  snoozedAlerts: new Map(),
-  retiredEntities: new Set(),
-  snoozedEntities: new Map(),
-  labeledEntities: new Map(),
-  resolvedOpens: new Set(),
-  promotedOpens: new Map(),
-};
-
-export function loadActionOverlay(db: Database.Database): ActionOverlay {
-  const hasActions = db
-    .prepare<[], { name: string }>("SELECT name FROM sqlite_master WHERE type='table' AND name='actions'")
-    .get();
-  if (!hasActions) return EMPTY_OVERLAY;
-
-  const overlay: ActionOverlay = {
-    dismissedAlerts: new Set(),
-    snoozedAlerts: new Map(),
-    retiredEntities: new Set(),
-    snoozedEntities: new Map(),
-    labeledEntities: new Map(),
-    resolvedOpens: new Set(),
-    promotedOpens: new Map(),
-  };
-
-  const rows = db
-    .prepare<[], ActionRow>(`
-      SELECT kind, subject_type, subject_id, payload
-      FROM actions
-      WHERE reverted_by IS NULL
-    `)
-    .all();
-
-  const now = new Date().toISOString();
-  for (const r of rows) {
-    const payload = r.payload ? (safeParse(r.payload) as Record<string, unknown> | null) : null;
-    if (r.kind === "dismiss" && r.subject_type === "alert") {
-      overlay.dismissedAlerts.add(r.subject_id);
-    } else if (r.kind === "snooze" && r.subject_type === "alert") {
-      const until = typeof payload?.["snoozed_until"] === "string" ? payload["snoozed_until"] : "";
-      if (until > now) overlay.snoozedAlerts.set(r.subject_id, until);
-    } else if (r.kind === "retire_entity" && r.subject_type === "entity") {
-      overlay.retiredEntities.add(r.subject_id);
-    } else if (r.kind === "snooze" && r.subject_type === "entity") {
-      const until = typeof payload?.["snoozed_until"] === "string" ? payload["snoozed_until"] : "";
-      if (until > now) overlay.snoozedEntities.set(r.subject_id, until);
-    } else if (r.kind === "label_entity" && r.subject_type === "entity") {
-      const newType = typeof payload?.["new_type"] === "string" ? payload["new_type"] : null;
-      if (newType) overlay.labeledEntities.set(r.subject_id, newType);
-    } else if (r.kind === "resolve_open" && r.subject_type === "open_question") {
-      overlay.resolvedOpens.add(r.subject_id);
-    } else if (r.kind === "promote_open" && r.subject_type === "open_question") {
-      const resolution = typeof payload?.["resolution"] === "string" ? payload["resolution"].trim() : "";
-      if (resolution) overlay.promotedOpens.set(r.subject_id, resolution);
-    }
-  }
-  return overlay;
-}
-
-/**
- * Stable id for an open question: `${sessionId}::${hash12(text)}`. Both
- * sides (overlay creators and consumers) compute it the same way so action
- * subject_ids round-trip.
- */
-export function openQuestionId(sessionId: string, text: string): string {
-  return `${sessionId}::${stableHash12(text)}`;
-}
-
-function stableHash12(text: string): string {
-  let h = 0xcbf29ce484222325n;
-  for (let i = 0; i < text.length; i++) {
-    h ^= BigInt(text.charCodeAt(i));
-    h = BigInt.asUintN(64, h * 0x100000001b3n);
-  }
-  return h.toString(16).padStart(16, "0").slice(0, 12);
-}
-
-function safeParse(s: string): unknown {
-  try {
-    return JSON.parse(s);
-  } catch {
-    return null;
-  }
-}

package/src/core/adapters/aider.ts

@@ -1,205 +0,0 @@
-/**
- * AiderAdapter — reads .aider.chat.history.md files.
- *
- * Aider stores chat sessions as Markdown in a per-project file. Each session
- * begins with a H1 header "# aider chat started at YYYY-MM-DD HH:MM:SS".
- * User turns are H4 headings (####); assistant responses are the plain text
- * that follows. Blockquote lines ("> ...") are Aider tool/file actions and
- * are summarized as [tool_action: ...].
- *
- * Default path: $AIDER_CHAT_HISTORY_FILE, or ~/.aider.chat.history.md.
- * For per-project files, configure pathOrUrl in the source registry.
- *
- * Session IDs: derived from the session header timestamp as ai_YYYYMMDD_HHMMSS.
- * sourcePath: <historyFile>::<rawTimestamp>  (e.g. ".../.aider.chat.history.md::2024-05-28 14:30:45")
- *
- * endedAt: next session's startedAt when available, else same as startedAt
- * (Aider's markdown format carries no per-turn or end-of-session timestamps).
- */
-
-import { existsSync, readFileSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import type {
-  DetectionResult,
-  DiscoverOptions,
-  SessionChunk,
-  TranscriptAdapter,
-} from "@ports/transcript-adapter.js";
-import { durationMinutes, safeSessionId } from "./common.js";
-
-export interface AiderAdapterOptions {
-  readonly historyFile?: string;
-}
-
-export function defaultHistoryFile(): string {
-  return (
-    process.env["AIDER_CHAT_HISTORY_FILE"] ??
-    join(homedir(), ".aider.chat.history.md")
-  );
-}
-
-// Matches "# aider chat started at YYYY-MM-DD HH:MM:SS"
-const SESSION_HEADER_RE = /^# aider chat started at (\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})/;
-
-const TOOL_ACTION_PREVIEW_CHARS = 200;
-
-interface ParsedTurn {
-  readonly role: "user" | "assistant";
-  readonly text: string;
-}
-
-interface ParsedSession {
-  readonly rawTimestamp: string;
-  readonly id: string;
-  readonly startedAt: string;
-  readonly turns: ReadonlyArray<ParsedTurn>;
-}
-
-function rawTimestampToId(raw: string): string {
-  // "2024-05-28 14:30:45" → "20240528_143045"
-  const compact = raw
-    .replace(/-/g, "")
-    .replace(/ /, "_")
-    .replace(/:/g, "");
-  return safeSessionId("ai", compact);
-}
-
-function processAssistantText(text: string): string {
-  return text
-    .split("\n")
-    .map((line) => {
-      if (!line.startsWith("> ")) return line;
-      const content = line.slice(2).trim().slice(0, TOOL_ACTION_PREVIEW_CHARS);
-      return `[tool_action: ${content}]`;
-    })
-    .join("\n")
-    .trim();
-}
-
-function extractTurns(body: string): ParsedTurn[] {
-  // Normalize so every turn block is preceded by \n####
-  const normalized = body.startsWith("#### ") ? "\n" + body : body;
-  const chunks = normalized.split("\n#### ").slice(1); // drop preamble
-
-  const turns: ParsedTurn[] = [];
-  for (const chunk of chunks) {
-    const nlIdx = chunk.indexOf("\n");
-    const userText = (nlIdx === -1 ? chunk : chunk.slice(0, nlIdx)).trim();
-    const rest = nlIdx === -1 ? "" : chunk.slice(nlIdx + 1).trim();
-
-    if (userText) turns.push({ role: "user", text: userText });
-    if (rest) {
-      const processed = processAssistantText(rest);
-      if (processed) turns.push({ role: "assistant", text: processed });
-    }
-  }
-  return turns;
-}
-
-function parseHistoryFile(filePath: string): ParsedSession[] {
-  let content: string;
-  try {
-    content = readFileSync(filePath, "utf-8");
-  } catch {
-    return [];
-  }
-
-  const lines = content.split("\n");
-  const sessionStarts: number[] = [];
-  for (let i = 0; i < lines.length; i++) {
-    if (SESSION_HEADER_RE.test(lines[i] ?? "")) sessionStarts.push(i);
-  }
-  if (sessionStarts.length === 0) return [];
-
-  const sessions: ParsedSession[] = [];
-  for (let si = 0; si < sessionStarts.length; si++) {
-    const startLine = sessionStarts[si] as number;
-    const endLine =
-      si + 1 < sessionStarts.length ? (sessionStarts[si + 1] as number) : lines.length;
-
-    const headerLine = lines[startLine] ?? "";
-    const match = SESSION_HEADER_RE.exec(headerLine);
-    if (!match) continue;
-
-    const rawTimestamp = match[1] as string;
-    const startedAt = new Date(rawTimestamp).toISOString();
-    const id = rawTimestampToId(rawTimestamp);
-    const body = lines.slice(startLine + 1, endLine).join("\n");
-    const turns = extractTurns(body);
-
-    sessions.push({ rawTimestamp, id, startedAt, turns });
-  }
-  return sessions;
-}
-
-export class AiderAdapter implements TranscriptAdapter {
-  readonly name = "aider";
-  readonly runtimeVersion = "aider/1.0";
-  readonly transcriptKind = "aider-markdown";
-
-  private readonly historyFile: string;
-
-  constructor(opts: AiderAdapterOptions = {}) {
-    this.historyFile = opts.historyFile ?? defaultHistoryFile();
-  }
-
-  detect(): DetectionResult {
-    if (existsSync(this.historyFile)) {
-      return { adapterName: this.name, enabled: true, path: this.historyFile, hint: null };
-    }
-    return {
-      adapterName: this.name,
-      enabled: false,
-      path: null,
-      hint: "Aider chat history not found — run aider in a project or set AIDER_CHAT_HISTORY_FILE.",
-    };
-  }
-
-  async discover(options?: DiscoverOptions): Promise<ReadonlyArray<string>> {
-    if (!existsSync(this.historyFile)) return [];
-    const sessions = parseHistoryFile(this.historyFile);
-    if (options?.since) {
-      const cutoff = options.since.getTime();
-      return sessions
-        .filter((s) => new Date(s.startedAt).getTime() >= cutoff)
-        .map((s) => s.id);
-    }
-    return sessions.map((s) => s.id);
-  }
-
-  async parseSession(id: string): Promise<SessionChunk | null> {
-    if (!existsSync(this.historyFile)) return null;
-    const sessions = parseHistoryFile(this.historyFile);
-    const idx = sessions.findIndex((s) => s.id === id);
-    if (idx === -1) return null;
-
-    const session = sessions[idx] as ParsedSession;
-    if (session.turns.length === 0) return null;
-
-    const nextSession = sessions[idx + 1] as ParsedSession | undefined;
-    const endedAt = nextSession ? nextSession.startedAt : session.startedAt;
-
-    const text = session.turns.map((t) => `${t.role}: ${t.text}`).join("\n\n");
-    const firstUser = session.turns.find((t) => t.role === "user");
-    const label = firstUser
-      ? firstUser.text.split("\n")[0]?.trim().slice(0, 80) ?? session.rawTimestamp
-      : session.rawTimestamp;
-
-    return {
-      id: session.id,
-      runtime: this.runtimeVersion,
-      runtimeSessionId: session.id,
-      sourcePath: `${this.historyFile}::${session.rawTimestamp}`,
-      startedAt: session.startedAt,
-      endedAt,
-      durationMin: durationMinutes(session.startedAt, endedAt),
-      turnCount: session.turns.length,
-      byteRange: [0, Buffer.byteLength(text, "utf8")],
-      projectDir: "",
-      gitBranch: "",
-      text,
-      label,
-    };
-  }
-}