@morlay/session-rdb 0.0.10 → 0.0.12

package/src/log.ts

@@ -0,0 +1,370 @@
+import type { SessionEvent, SessionHeader, SessionId, SurfaceOp } from "@deepseek-ai/dsh-session";
+import { SessionSeq, encodeSeqRanges, packChunkRuns } from "@deepseek-ai/dsh-session";
+import type { SessionStorageMetadata } from "@deepseek-ai/dsh-session-persistence";
+import type { EventRow, SessionRow } from "./backend.ts";
+
+export function rowToMeta(row: SessionRow): SessionHeader {
+  if (!Number.isSafeInteger(row.fCreatedAt) || row.fCreatedAt < 0) {
+    throw new Error("stored session createdAt must be a non-negative safe integer");
+  }
+  return {
+    version: row.fVersion,
+    id: row.fSessionId as SessionId,
+    createdAt: row.fCreatedAt,
+    ...(row.fCwd !== null ? { cwd: row.fCwd } : {}),
+    ...(row.fParentSession !== null ? { parentSession: row.fParentSession as SessionId } : {}),
+    isSeeded: row.fSeedLength !== null,
+    ...(row.fOrigin !== null ? { origin: row.fOrigin as "subagent" } : {}),
+    ...(row.fDelegationDepth === null ? {} : { delegationDepth: row.fDelegationDepth }),
+  };
+}
+
+export function sessionInsertRow(
+  storage: SessionStorageMetadata,
+  incarnation: string,
+): {
+  fSessionId: string;
+  fHeadEventId: string;
+  fHeadSequence: number;
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+  fIncarnation: string;
+  fRevision: number;
+} {
+  const meta = storage.meta;
+  return {
+    fSessionId: meta.id,
+    fHeadEventId: "",
+    fHeadSequence: -1,
+    fVersion: meta.version,
+    fCreatedAt: meta.createdAt,
+    fCwd: meta.cwd ?? null,
+    fParentSession: meta.parentSession ?? null,
+    fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+    fOrigin: meta.origin ?? null,
+    fDelegationDepth: meta.delegationDepth ?? null,
+    fIncarnation: incarnation,
+    fRevision: 0,
+  };
+}
+
+export function sessionConflictRow(storage: SessionStorageMetadata): {
+  fVersion: number;
+  fCreatedAt: number;
+  fCwd: string | null;
+  fParentSession: string | null;
+  fSeedLength: number | null;
+  fOrigin: string | null;
+  fDelegationDepth: number | null;
+} {
+  const meta = storage.meta;
+  return {
+    fVersion: meta.version,
+    fCreatedAt: meta.createdAt,
+    fCwd: meta.cwd ?? null,
+    fParentSession: meta.parentSession ?? null,
+    fSeedLength: meta.isSeeded ? storage.inheritedEventCount : null,
+    fOrigin: meta.origin ?? null,
+    fDelegationDepth: meta.delegationDepth ?? null,
+  };
+}
+
+export function remapSurfaceOp(op: SurfaceOp, remap: (seq: number) => number): SurfaceOp {
+  if (op === "append") return op;
+  return {
+    op: "replace",
+    start: SessionSeq(remap(op.start)),
+    end: SessionSeq(remap(op.end)),
+  };
+}
+
+export function remapShadowedRange(
+  range: { start: number; end: number },
+  remap: (seq: number) => number,
+): { start: number; end: number } {
+  return { start: remap(range.start), end: remap(range.end) };
+}
+
+export function rowToEvent(row: EventRow, seqMap: ReadonlyMap<number, number>): SessionEvent {
+  const remap = (seq: number): number => seqMap.get(seq) ?? seq;
+  const surfaceOp =
+    row.fSurfaceOp !== null
+      ? remapSurfaceOp(JSON.parse(row.fSurfaceOp) as SurfaceOp, remap)
+      : undefined;
+  const data = JSON.parse(row.fData) as SessionEvent["data"];
+  // compaction 事件的 shadowedRange 是插件合并字段，经结构化视图重映射。
+  if (row.fType === "compaction/summary" || row.fType === "compaction/prune") {
+    const metering = data as unknown as { shadowedRange?: { start: number; end: number } };
+    if (metering.shadowedRange !== undefined) {
+      metering.shadowedRange = remapShadowedRange(metering.shadowedRange, remap);
+    }
+  }
+  return {
+    type: row.fType as SessionEvent["type"],
+    seq: row.fSequence,
+    time: row.fCreatedAt,
+    data,
+    ...(surfaceOp === undefined ? {} : { surfaceOp }),
+  } as SessionEvent;
+}
+
+export function buildSeqMap(
+  rows: readonly Pick<EventRow, "fSequence" | "fOriginalSeq">[],
+): Map<number, number> {
+  const map = new Map<number, number>();
+  for (const row of rows) {
+    if (!map.has(row.fOriginalSeq)) map.set(row.fOriginalSeq, row.fSequence);
+  }
+  return map;
+}
+
+const SURFACE_EVENT_TYPES = new Set(["user/message", "assistant/message", "tool/result"]);
+
+export function recomputeReplaceProvenance(events: SessionEvent[]): void {
+  for (const event of events) {
+    const raw = event as SessionEvent & { surfaceOp?: unknown; sourceEventSeqs?: number[] };
+    const op = raw.surfaceOp;
+    if (typeof op !== "object" || op === null || (op as { op?: string }).op !== "replace") {
+      continue;
+    }
+    const { start, end } = op as { start: number; end: number };
+    const refs: number[] = [];
+    for (const candidate of events) {
+      if (
+        candidate.seq >= start &&
+        candidate.seq <= end &&
+        SURFACE_EVENT_TYPES.has(candidate.type)
+      ) {
+        refs.push(candidate.seq);
+      }
+    }
+    raw.sourceEventSeqs = refs;
+  }
+}
+
+function isEventSeqLike(value: unknown): value is number {
+  return (
+    typeof value === "number" && Number.isSafeInteger(value) && value >= 0 && !Object.is(value, -0)
+  );
+}
+
+function isDeepEqualJson(a: unknown, b: unknown): boolean {
+  if (a === b) return true;
+  if (Array.isArray(a) || Array.isArray(b)) {
+    if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length) return false;
+    return a.every((item, i) => isDeepEqualJson(item, b[i]));
+  }
+  if (typeof a !== "object" || typeof b !== "object" || a === null || b === null) return false;
+  const aKeys = Object.keys(a as Record<string, unknown>);
+  const bRecord = b as Record<string, unknown>;
+  if (aKeys.length !== Object.keys(bRecord).length) return false;
+  return aKeys.every(
+    (key) =>
+      Object.hasOwn(bRecord, key) &&
+      isDeepEqualJson((a as Record<string, unknown>)[key], bRecord[key]),
+  );
+}
+
+function toolResultRewriteContentOnly(original: SessionEvent, replacement: SessionEvent): boolean {
+  const originalData = original.data as Record<string, unknown>;
+  const replacementData = replacement.data as Record<string, unknown>;
+  const originalMessage = originalData["message"] as { content?: unknown } | undefined;
+  const replacementMessage = replacementData["message"] as { content?: unknown } | undefined;
+  const originalContent = Array.isArray(originalMessage?.content)
+    ? originalMessage.content
+    : undefined;
+  const replacementContent = Array.isArray(replacementMessage?.content)
+    ? replacementMessage.content
+    : undefined;
+  if (originalContent === undefined || replacementContent === undefined) return false;
+  const originalRest = {
+    ...originalData,
+    message: {
+      ...originalMessage,
+      content: [{ ...(originalContent[0] as Record<string, unknown>), content: null }],
+    },
+  };
+  const replacementRest = {
+    ...replacementData,
+    message: {
+      ...replacementMessage,
+      content: [{ ...(replacementContent[0] as Record<string, unknown>), content: null }],
+    },
+  };
+  return isDeepEqualJson(originalRest, replacementRest);
+}
+
+export function findSurfaceRepairs(events: readonly SessionEvent[]): {
+  degradeToAppend: Set<number>;
+  addAppendMarker: Set<number>;
+  clearSurfaceOp: Set<number>;
+} {
+  const nodes: number[] = [];
+  const degradeToAppend = new Set<number>();
+  const addAppendMarker = new Set<number>();
+  const clearSurfaceOp = new Set<number>();
+  for (const event of events) {
+    const raw = event as SessionEvent & { surfaceOp?: unknown };
+    const op = raw.surfaceOp;
+    if (op === undefined) {
+      if (SURFACE_EVENT_TYPES.has(event.type)) {
+        addAppendMarker.add(event.seq);
+        nodes.push(event.seq);
+      }
+      continue;
+    }
+    if (op === "append") {
+      if (SURFACE_EVENT_TYPES.has(event.type)) nodes.push(event.seq);
+      else clearSurfaceOp.add(event.seq);
+      continue;
+    }
+    if (!SURFACE_EVENT_TYPES.has(event.type)) {
+      clearSurfaceOp.add(event.seq);
+      continue;
+    }
+    const replace =
+      typeof op === "object" && op !== null && !Array.isArray(op)
+        ? (op as Record<string, unknown>)
+        : undefined;
+    const start = replace?.["start"];
+    const end = replace?.["end"];
+    const shapeOk =
+      replace !== undefined &&
+      replace["op"] === "replace" &&
+      isEventSeqLike(start) &&
+      isEventSeqLike(end);
+    const startIdx = shapeOk ? nodes.indexOf(start as number) : -1;
+    const endIdx = shapeOk ? nodes.indexOf(end as number) : -1;
+    const rangeOk = shapeOk && startIdx !== -1 && endIdx !== -1 && startIdx <= endIdx;
+    let rewriteOk = true;
+    if (rangeOk && event.type === "tool/result") {
+      const shadowed = nodes.slice(startIdx, endIdx + 1);
+      if (shadowed.length !== 1) {
+        rewriteOk = false;
+      } else {
+        const original = events[shadowed[0]!];
+        rewriteOk =
+          original?.type === "tool/result" && toolResultRewriteContentOnly(original, event);
+      }
+    }
+    if (!rangeOk || !rewriteOk) {
+      degradeToAppend.add(event.seq);
+      nodes.push(event.seq);
+      continue;
+    }
+    nodes.splice(startIdx, endIdx - startIdx + 1, event.seq);
+  }
+  return { degradeToAppend, addAppendMarker, clearSurfaceOp };
+}
+
+export function repairSurfaceOps(events: SessionEvent[]): void {
+  const repairs = findSurfaceRepairs(events);
+  if (
+    repairs.degradeToAppend.size === 0 &&
+    repairs.addAppendMarker.size === 0 &&
+    repairs.clearSurfaceOp.size === 0
+  ) {
+    return;
+  }
+  for (const event of events) {
+    const raw = event as SessionEvent & { surfaceOp?: unknown };
+    if (repairs.degradeToAppend.has(event.seq)) {
+      raw.surfaceOp = "append";
+    } else if (repairs.addAppendMarker.has(event.seq)) {
+      raw.surfaceOp = "append";
+    } else if (repairs.clearSurfaceOp.has(event.seq)) {
+      delete raw.surfaceOp;
+    }
+  }
+}
+
+export function scanRows(
+  rows: readonly EventRow[],
+  base = 0,
+  seqMap: ReadonlyMap<number, number> = new Map(),
+): { preserved: SessionEvent[]; tornFrom?: number } {
+  // Pass 1：解析每行 data；JSON 非法的行是洞（seq/type 列即使在 data 损坏
+  // 时也存在）。
+  interface Parsed {
+    ok: boolean;
+    event?: SessionEvent;
+  }
+  const parsed: Parsed[] = rows.map((row) => {
+    try {
+      return { ok: true, event: rowToEvent(row, seqMap) };
+    } catch {
+      return { ok: false };
+    }
+  });
+
+  // 最后一个合法 turn/end 的索引——洞在闭合轮内一律是已提交损坏。
+  let lastTurnEnd = -1;
+  for (let i = parsed.length - 1; i >= 0; i--) {
+    if (parsed[i]?.ok && rows[i]?.fType === "turn/end") {
+      lastTurnEnd = i;
+      break;
+    }
+  }
+
+  // 保留连续前缀（含完整的中断轮）；最后一个已提交边界之前的洞抛错，
+  // 之后的洞停止（torn tail）。
+  const preserved: SessionEvent[] = [];
+  for (let i = 0; i < rows.length; i++) {
+    const p = parsed[i];
+    if (!p?.ok || p.event === undefined) {
+      if (i <= lastTurnEnd)
+        throw new Error(
+          `corrupt session log: unparsable committed event at seq ${rows[i]?.fSequence}`,
+        );
+      break; // 最后一个 turn/end 之后的 torn tail 片段——停止、容忍
+    }
+    if (p.event.seq !== base + i) {
+      if (i <= lastTurnEnd)
+        throw new Error(
+          `corrupt session log: seq gap in committed region (expected ${base + i}, got ${p.event.seq})`,
+        );
+      break; // 最后一个 turn/end 之后的 seq 空洞——torn tail，停止
+    }
+    preserved.push(p.event);
+  }
+
+  // 保留前缀之外的行是未提交的 torn tail；其首个 seq 是物理删除起点。
+  return preserved.length < rows.length
+    ? { preserved, tornFrom: base + preserved.length }
+    : { preserved };
+}
+
+function toStorageRecord(record: import("@deepseek-ai/dsh-session").StorageRecord): unknown {
+  const withSeqs = record as import("@deepseek-ai/dsh-session").StorageRecord & {
+    sourceEventSeqs?: unknown;
+  };
+  if (withSeqs.sourceEventSeqs === undefined) return record;
+  return { ...record, sourceEventSeqs: encodeSeqRanges(withSeqs.sourceEventSeqs as never) };
+}
+
+export function toJsonlArtifact(
+  meta: SessionHeader,
+  inheritedEventCount: number,
+  events: readonly SessionEvent[],
+): string {
+  const header = {
+    type: "session",
+    version: meta.version,
+    id: meta.id,
+    createdAt: meta.createdAt,
+    ...(meta.cwd === undefined ? {} : { cwd: meta.cwd }),
+    ...(meta.parentSession === undefined ? {} : { parentSession: meta.parentSession }),
+    ...(meta.isSeeded ? { seedLength: inheritedEventCount } : {}),
+    ...(meta.origin === undefined ? {} : { origin: meta.origin }),
+    delegationDepth: meta.delegationDepth ?? 0,
+    ...(meta.agentPreset === undefined ? {} : { agentPreset: meta.agentPreset }),
+  };
+  const lines = [JSON.stringify(header)];
+  for (const record of packChunkRuns(events)) lines.push(JSON.stringify(toStorageRecord(record)));
+  return lines.join("\n");
+}

package/src/migrate.ts

@@ -0,0 +1,137 @@
+import { DatabaseSync } from "node:sqlite";
+import { eventDimensions } from "./schema.ts";
+
+export const SCHEMA_VERSION_V2 = 2;
+
+export function migrateSqliteV1ToV2(db: DatabaseSync): number {
+  const { user_version: onDisk } = db.prepare("PRAGMA user_version").get() as {
+    user_version: number;
+  };
+  if (onDisk === SCHEMA_VERSION_V2) return 0;
+  if (onDisk !== 1) {
+    throw new Error(`unsupported schema version ${onDisk} (expected 1)`);
+  }
+
+  // 1. 建 v2 表（临时名）。
+  db.exec(`
+    CREATE TABLE t_events_v2 (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_event_id TEXT NOT NULL UNIQUE,
+      f_parent_id TEXT NOT NULL DEFAULT '',
+      f_type TEXT NOT NULL DEFAULT '',
+      f_kind TEXT NOT NULL DEFAULT '',
+      f_role TEXT NOT NULL DEFAULT '',
+      f_name TEXT NOT NULL DEFAULT '',
+      f_action_id TEXT NOT NULL DEFAULT '',
+      f_encoding TEXT NOT NULL DEFAULT '',
+      f_data TEXT NOT NULL,
+      f_created_at INTEGER NOT NULL DEFAULT 0
+    ) STRICT;
+    CREATE TABLE t_session_events_v2 (
+      f_id INTEGER PRIMARY KEY AUTOINCREMENT,
+      f_session_id TEXT NOT NULL REFERENCES t_sessions(f_session_id) ON DELETE CASCADE,
+      f_event_id TEXT NOT NULL REFERENCES t_events_v2(f_event_id) ON DELETE CASCADE,
+      f_sequence INTEGER NOT NULL,
+      f_original_seq INTEGER NOT NULL,
+      f_surface_op TEXT,
+      UNIQUE (f_session_id, f_sequence)
+    ) STRICT;
+    CREATE INDEX idx_events_v2_kind ON t_events_v2(f_kind);
+    CREATE INDEX idx_events_v2_role ON t_events_v2(f_role);
+    CREATE INDEX idx_events_v2_name ON t_events_v2(f_name);
+    CREATE INDEX idx_events_v2_action_id ON t_events_v2(f_action_id);
+    CREATE INDEX idx_session_events_v2_event_id ON t_session_events_v2(f_event_id);
+  `);
+
+  // 2. 搬运 t_events：f_type = 旧 f_kind，维度列重算。
+  const oldEvents = db
+    .prepare(
+      `SELECT f_event_id, f_parent_id, f_kind, f_data, f_created_at FROM t_events ORDER BY f_id`,
+    )
+    .all() as Array<{
+    f_event_id: string;
+    f_parent_id: string;
+    f_kind: string;
+    f_data: string;
+    f_created_at: number;
+  }>;
+  const insertEvent = db.prepare(`
+    INSERT INTO t_events_v2
+      (f_event_id, f_parent_id, f_type, f_kind, f_role, f_name, f_action_id, f_encoding, f_data, f_created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?, 'json', ?, ?)
+  `);
+  for (const row of oldEvents) {
+    let data: unknown;
+    try {
+      data = JSON.parse(row.f_data);
+    } catch {
+      throw new Error(`t_events row ${row.f_event_id} has unparsable f_data; aborting`);
+    }
+    const dims = eventDimensions({
+      type: row.f_kind,
+      seq: 0,
+      time: row.f_created_at,
+      data,
+    } as never);
+    insertEvent.run(
+      row.f_event_id,
+      row.f_parent_id,
+      row.f_kind,
+      dims.kind,
+      dims.role,
+      dims.name,
+      dims.actionId,
+      row.f_data,
+      row.f_created_at,
+    );
+  }
+
+  // 3. 搬运 t_session_events：f_original_seq / f_surface_op 从旧 t_events 取。
+  const oldBridges = db
+    .prepare(
+      `SELECT se.f_session_id, se.f_event_id, se.f_sequence
+       FROM t_session_events se ORDER BY se.f_id`,
+    )
+    .all() as Array<{ f_session_id: string; f_event_id: string; f_sequence: number }>;
+  const oldEventMeta = new Map(
+    (
+      db.prepare(`SELECT f_event_id, f_original_seq, f_surface_op FROM t_events`).all() as Array<{
+        f_event_id: string;
+        f_original_seq: number;
+        f_surface_op: string | null;
+      }>
+    ).map((row) => [row.f_event_id, row]),
+  );
+  const insertBridge = db.prepare(`
+    INSERT INTO t_session_events_v2
+      (f_session_id, f_event_id, f_sequence, f_original_seq, f_surface_op)
+    VALUES (?, ?, ?, ?, ?)
+  `);
+  for (const row of oldBridges) {
+    const meta = oldEventMeta.get(row.f_event_id);
+    if (meta === undefined) {
+      throw new Error(
+        `bridge row ${row.f_session_id}:${row.f_sequence} references missing event ${row.f_event_id}`,
+      );
+    }
+    insertBridge.run(
+      row.f_session_id,
+      row.f_event_id,
+      row.f_sequence,
+      meta.f_original_seq,
+      meta.f_surface_op,
+    );
+  }
+
+  // 4. 删旧表、重命名新表。
+  db.exec(`
+    DROP TABLE t_session_events;
+    DROP TABLE t_events;
+    ALTER TABLE t_events_v2 RENAME TO t_events;
+    ALTER TABLE t_session_events_v2 RENAME TO t_session_events;
+  `);
+
+  // 5. user_version = 2。
+  db.exec(`PRAGMA user_version = ${SCHEMA_VERSION_V2}`);
+  return oldEvents.length;
+}