@nothumanwork/nn 0.1.0

package/src/db/replica-migrate.ts

@@ -0,0 +1,162 @@
+import { existsSync, mkdirSync, renameSync } from "node:fs";
+import { basename, join } from "node:path";
+
+import { createClient, type Client, type Value } from "@libsql/client";
+
+import { tursoConfigured } from "../config/sync.ts";
+
+const BACKUP_SUFFIX = ".pre-sync-backup";
+const IMPORTED_SUFFIX = ".pre-sync-imported";
+const RECOVERY_SUFFIX = ".conflict-recovery";
+
+export function isReplicaConflictError(error: unknown): boolean {
+  const parts: string[] = [];
+  let current: unknown = error;
+  while (current instanceof Error) {
+    parts.push(current.message);
+    current = current.cause;
+  }
+  if (typeof error === "object" && error !== null && "code" in error) {
+    parts.push(String((error as { code?: unknown }).code));
+  }
+  const message = parts.join(" ");
+  return (
+    message.includes("WalConflict") ||
+    message.includes("SQLITE_CORRUPT") ||
+    message.includes("database disk image is malformed")
+  );
+}
+
+export function recoverEmbeddedReplica(dbPath: string): string {
+  const backupDir = `${dbPath}${RECOVERY_SUFFIX}-${Date.now()}`;
+  mkdirSync(backupDir, { recursive: true });
+
+  for (const suffix of ["", "-wal", "-shm", "-info"]) {
+    const source = `${dbPath}${suffix}`;
+    if (!existsSync(source)) {
+      continue;
+    }
+    renameSync(source, join(backupDir, `${basename(dbPath)}${suffix}`));
+  }
+
+  console.error(
+    `[nn-db] reset embedded replica after conflict; backup at ${backupDir}`,
+  );
+  return backupDir;
+}
+
+export function replicaInfoPath(dbPath: string): string {
+  return `${dbPath}-info`;
+}
+
+export function localBackupDir(dbPath: string): string {
+  return `${dbPath}${BACKUP_SUFFIX}`;
+}
+
+export function importedBackupDir(dbPath: string): string {
+  return `${dbPath}${IMPORTED_SUFFIX}`;
+}
+
+export function isLocalOnlyReplica(dbPath: string): boolean {
+  return existsSync(dbPath) && !existsSync(replicaInfoPath(dbPath));
+}
+
+export function findPendingBackup(dbPath: string): string | null {
+  const pending = localBackupDir(dbPath);
+  if (existsSync(join(pending, basename(dbPath)))) {
+    return pending;
+  }
+  return null;
+}
+
+export function prepareForEmbeddedReplica(dbPath: string): string | null {
+  if (!tursoConfigured() || !isLocalOnlyReplica(dbPath)) {
+    return null;
+  }
+
+  const backupDir = localBackupDir(dbPath);
+  mkdirSync(backupDir, { recursive: true });
+
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const source = `${dbPath}${suffix}`;
+    if (!existsSync(source)) {
+      continue;
+    }
+    renameSync(source, join(backupDir, `${basename(dbPath)}${suffix}`));
+  }
+
+  console.error(
+    `[nn-db] migrated local-only database to embedded replica; backup at ${backupDir}`,
+  );
+  return backupDir;
+}
+
+const IMPORT_TABLES = [
+  "projects",
+  "sessions",
+  "events",
+  "source_cursors",
+  "exports",
+  "schema_migrations",
+] as const;
+
+export async function importPendingLocalBackup(
+  client: Client,
+  dbPath: string,
+): Promise<{ imported: boolean; backupPath: string | null }> {
+  const backupDir = findPendingBackup(dbPath);
+  if (!backupDir) {
+    return { imported: false, backupPath: null };
+  }
+
+  const backupDb = join(backupDir, basename(dbPath));
+  const backupClient = createClient({
+    url: backupDb.startsWith("file:") ? backupDb : `file:${backupDb}`,
+  });
+
+  try {
+    for (const table of IMPORT_TABLES) {
+      const result = await backupClient.execute(`SELECT * FROM ${table}`);
+      if (result.rows.length === 0) {
+        continue;
+      }
+
+      const columns = result.columns;
+      const placeholders = columns.map(() => "?").join(", ");
+      const sql = `INSERT OR IGNORE INTO ${table} (${columns.join(", ")}) VALUES (${placeholders})`;
+
+      await client.execute("BEGIN");
+      try {
+        for (const row of result.rows) {
+          await client.execute({
+            sql,
+            args: columns.map((column) => {
+              const value = row[column as keyof typeof row];
+              return (value ?? null) as Value;
+            }),
+          });
+        }
+        await client.execute("COMMIT");
+      } catch (error) {
+        await client.execute("ROLLBACK");
+        throw error;
+      }
+    }
+
+    await backupClient.close();
+    renameSync(backupDir, importedBackupDir(dbPath));
+    console.error(
+      `[nn-db] imported local backup into embedded replica from ${backupDir}`,
+    );
+
+    if (tursoConfigured()) {
+      await client.sync();
+    }
+
+    return { imported: true, backupPath: importedBackupDir(dbPath) };
+  } catch (error) {
+    console.error("[nn-db] failed to import local backup", error);
+    await backupClient.close();
+    return { imported: false, backupPath: backupDir };
+  }
+}

package/src/db/schema.sql

@@ -0,0 +1,99 @@
+CREATE TABLE IF NOT EXISTS schema_migrations (
+  version INTEGER PRIMARY KEY,
+  name TEXT NOT NULL,
+  checksum TEXT NOT NULL,
+  applied_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS projects (
+  id TEXT PRIMARY KEY,
+  canonical_path TEXT NOT NULL UNIQUE,
+  display_name TEXT NOT NULL,
+  created_at INTEGER NOT NULL,
+  updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sessions (
+  id TEXT PRIMARY KEY,
+  project_id TEXT NOT NULL REFERENCES projects(id),
+  source TEXT NOT NULL,
+  source_session_id TEXT NOT NULL,
+  workspace_root TEXT,
+  source_path TEXT,
+  title TEXT,
+  model TEXT,
+  started_at TEXT,
+  updated_at TEXT,
+  created_at INTEGER NOT NULL,
+  modified_at INTEGER NOT NULL,
+  UNIQUE(project_id, source, source_session_id)
+);
+
+CREATE TABLE IF NOT EXISTS events (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id),
+  seq INTEGER NOT NULL,
+  boundary TEXT NOT NULL,
+  role TEXT NOT NULL,
+  timestamp TEXT NOT NULL,
+  content_text TEXT NOT NULL DEFAULT '',
+  tool_name TEXT,
+  tool_call_id TEXT,
+  tool_input_json TEXT,
+  tool_output_json TEXT,
+  raw_json TEXT NOT NULL,
+  parser_version TEXT NOT NULL,
+  raw_local_ref TEXT NOT NULL,
+  line_key TEXT NOT NULL,
+  content_hash TEXT NOT NULL,
+  created_at INTEGER NOT NULL
+);
+
+CREATE INDEX IF NOT EXISTS idx_events_session_seq ON events(session_id, seq);
+CREATE INDEX IF NOT EXISTS idx_events_line_key ON events(line_key);
+CREATE INDEX IF NOT EXISTS idx_sessions_source ON sessions(source, source_session_id);
+
+CREATE TABLE IF NOT EXISTS source_cursors (
+  source TEXT NOT NULL,
+  cursor_key TEXT NOT NULL,
+  last_byte_offset INTEGER NOT NULL DEFAULT 0,
+  last_line_uuid TEXT,
+  parser_version TEXT NOT NULL,
+  cursor_value TEXT,
+  updated_at INTEGER NOT NULL,
+  PRIMARY KEY (source, cursor_key)
+);
+
+CREATE TABLE IF NOT EXISTS exports (
+  id TEXT PRIMARY KEY,
+  session_id TEXT NOT NULL REFERENCES sessions(id),
+  target_provider TEXT NOT NULL,
+  output_path TEXT NOT NULL,
+  exported_at INTEGER NOT NULL,
+  lossy INTEGER NOT NULL DEFAULT 0,
+  warnings_json TEXT NOT NULL DEFAULT '[]'
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS events_fts USING fts5(
+  content_text,
+  tool_name,
+  content='events',
+  content_rowid='rowid'
+);
+
+CREATE TRIGGER IF NOT EXISTS events_ai AFTER INSERT ON events BEGIN
+  INSERT INTO events_fts(rowid, content_text, tool_name)
+  VALUES (new.rowid, new.content_text, COALESCE(new.tool_name, ''));
+END;
+
+CREATE TRIGGER IF NOT EXISTS events_ad AFTER DELETE ON events BEGIN
+  INSERT INTO events_fts(events_fts, rowid, content_text, tool_name)
+  VALUES ('delete', old.rowid, old.content_text, COALESCE(old.tool_name, ''));
+END;
+
+CREATE TRIGGER IF NOT EXISTS events_au AFTER UPDATE ON events BEGIN
+  INSERT INTO events_fts(events_fts, rowid, content_text, tool_name)
+  VALUES ('delete', old.rowid, old.content_text, COALESCE(old.tool_name, ''));
+  INSERT INTO events_fts(rowid, content_text, tool_name)
+  VALUES (new.rowid, new.content_text, COALESCE(new.tool_name, ''));
+END;

package/src/export/claude.ts

@@ -0,0 +1,92 @@
+import { randomUUID } from "node:crypto";
+
+import type { ExportContext, ExportResult, HarnessExporter } from "./types.ts";
+
+export const claudeExporter: HarnessExporter = {
+  target: "claude",
+  export(context: ExportContext): ExportResult {
+    const warnings = [];
+    const lines: string[] = [];
+
+    for (const event of context.events) {
+      if (event.boundary === "tool_result") {
+        lines.push(
+          JSON.stringify({
+            type: "assistant",
+            sessionId: context.sourceSessionId,
+            uuid: randomUUID(),
+            timestamp: event.timestamp,
+            message: {
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_result",
+                  tool_use_id: event.toolCallId,
+                  content:
+                    event.toolOutputJson ?
+                      JSON.parse(event.toolOutputJson)
+                    : event.contentText,
+                },
+              ],
+            },
+          }),
+        );
+        continue;
+      }
+
+      if (event.boundary === "tool_call") {
+        lines.push(
+          JSON.stringify({
+            type: "assistant",
+            sessionId: context.sourceSessionId,
+            uuid: randomUUID(),
+            timestamp: event.timestamp,
+            message: {
+              role: "assistant",
+              content: [
+                {
+                  type: "tool_use",
+                  id: event.toolCallId ?? randomUUID(),
+                  name: event.toolName ?? "tool",
+                  input:
+                    event.toolInputJson ? JSON.parse(event.toolInputJson) : {},
+                },
+              ],
+            },
+          }),
+        );
+        continue;
+      }
+
+      if (!event.contentText.trim()) {
+        continue;
+      }
+
+      const type =
+        event.role === "user" ? "user"
+        : event.role === "assistant" ? "assistant"
+        : "system";
+      lines.push(
+        JSON.stringify({
+          type,
+          sessionId: context.sourceSessionId,
+          uuid: randomUUID(),
+          timestamp: event.timestamp,
+          message: {
+            role: type,
+            content: event.contentText,
+          },
+        }),
+      );
+    }
+
+    if (context.source !== "claude") {
+      warnings.push({
+        code: "cross_export",
+        message: `Exporting ${context.source} session to Claude-compatible JSONL may be lossy`,
+      });
+    }
+
+    return { lines, lossy: warnings.length > 0, warnings };
+  },
+};

package/src/export/codex.ts

@@ -0,0 +1,86 @@
+import type { ExportContext, ExportResult, HarnessExporter } from "./types.ts";
+
+export const codexExporter: HarnessExporter = {
+  target: "codex",
+  export(context: ExportContext): ExportResult {
+    const warnings = [];
+    const lines: string[] = [
+      JSON.stringify({
+        type: "session_meta",
+        timestamp: context.events[0]?.timestamp ?? new Date().toISOString(),
+        payload: {
+          id: context.sourceSessionId,
+          cwd: process.cwd(),
+          model_provider: "openai",
+          model: "gpt-5.4",
+        },
+      }),
+    ];
+
+    for (const event of context.events) {
+      if (event.boundary === "user_turn") {
+        lines.push(
+          JSON.stringify({
+            type: "event_msg",
+            timestamp: event.timestamp,
+            payload: { type: "user_message", message: event.contentText },
+          }),
+        );
+        continue;
+      }
+      if (event.boundary === "tool_call") {
+        lines.push(
+          JSON.stringify({
+            type: "response_item",
+            timestamp: event.timestamp,
+            payload: {
+              type: "function_call",
+              name: event.toolName ?? "tool",
+              arguments: event.toolInputJson ?? "{}",
+              call_id: event.toolCallId ?? `call_${event.seq}`,
+            },
+          }),
+        );
+        continue;
+      }
+      if (event.boundary === "tool_result") {
+        lines.push(
+          JSON.stringify({
+            type: "response_item",
+            timestamp: event.timestamp,
+            payload: {
+              type: "function_call_output",
+              call_id: event.toolCallId ?? `call_${event.seq}`,
+              output:
+                event.toolOutputJson ?
+                  JSON.parse(event.toolOutputJson)
+                : event.contentText,
+            },
+          }),
+        );
+        continue;
+      }
+      if (event.boundary === "assistant_turn" && event.contentText.trim()) {
+        lines.push(
+          JSON.stringify({
+            type: "response_item",
+            timestamp: event.timestamp,
+            payload: {
+              role: "assistant",
+              content: [{ type: "output_text", text: event.contentText }],
+            },
+          }),
+        );
+      }
+    }
+
+    if (context.source !== "codex") {
+      warnings.push({
+        code: "cross_export",
+        message: `Exporting ${context.source} session to Codex rollout JSONL may be lossy`,
+      });
+    }
+
+    return { lines, lossy: warnings.length > 0, warnings };
+  },
+};

package/src/export/cursor.ts

@@ -0,0 +1,68 @@
+import type { ExportContext, ExportResult, HarnessExporter } from "./types.ts";
+
+export const cursorExporter: HarnessExporter = {
+  target: "cursor",
+  export(context: ExportContext): ExportResult {
+    const warnings = [];
+    const lines: string[] = [];
+    let current: {
+      role: string;
+      content: Array<Record<string, unknown>>;
+    } | null = null;
+
+    const flush = (): void => {
+      if (current && current.content.length > 0) {
+        lines.push(
+          JSON.stringify({
+            role: current.role,
+            message: { content: current.content },
+          }),
+        );
+      }
+      current = null;
+    };
+
+    for (const event of context.events) {
+      if (event.boundary === "tool_result") {
+        warnings.push({
+          code: "tool_result_omitted",
+          message: "Cursor export omits explicit tool_result rows",
+        });
+        continue;
+      }
+      if (event.boundary === "compaction") {
+        warnings.push({
+          code: "thinking_stripped",
+          message: "Compaction/thinking rows omitted",
+        });
+        continue;
+      }
+
+      const role = event.role === "tool" ? "assistant" : event.role;
+      if (!current || current.role !== role) {
+        flush();
+        current = { role, content: [] };
+      }
+
+      if (event.boundary === "tool_call") {
+        current.content.push({
+          type: "tool_use",
+          name: event.toolName ?? "tool",
+          input: event.toolInputJson ? JSON.parse(event.toolInputJson) : {},
+        });
+        continue;
+      }
+
+      if (event.contentText.trim()) {
+        current.content.push({ type: "text", text: event.contentText });
+      }
+    }
+    flush();
+
+    return {
+      lines,
+      lossy: warnings.length > 0 || context.source !== "cursor",
+      warnings,
+    };
+  },
+};

package/src/export/generic.ts

@@ -0,0 +1,19 @@
+import type { ExportContext, ExportResult, HarnessExporter } from "./types.ts";
+
+export const genericExporter: HarnessExporter = {
+  target: "generic",
+  export(context: ExportContext): ExportResult {
+    const lines = context.events.map((event) =>
+      JSON.stringify({
+        boundary: event.boundary,
+        role: event.role,
+        timestamp: event.timestamp,
+        contentText: event.contentText,
+        toolName: event.toolName,
+        toolCallId: event.toolCallId,
+        raw: JSON.parse(event.rawJson),
+      }),
+    );
+    return { lines, lossy: false, warnings: [] };
+  },
+};

package/src/export/registry.ts

@@ -0,0 +1,118 @@
+import { mkdirSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+
+import { recordExport } from "../db/client.ts";
+import { getSessionEvents } from "../db/client.ts";
+import { findSessionBySourceId } from "../db/client.ts";
+import type { ProviderId } from "../ir/types.ts";
+import { claudeExporter } from "./claude.ts";
+import { codexExporter } from "./codex.ts";
+import { cursorExporter } from "./cursor.ts";
+import { genericExporter } from "./generic.ts";
+import type { ExportManifest, ExportTarget, HarnessExporter } from "./types.ts";
+
+const exporters: Record<ExportTarget, HarnessExporter> = {
+  generic: genericExporter,
+  cursor: cursorExporter,
+  claude: claudeExporter,
+  codex: codexExporter,
+  copilot: genericExporter,
+  antigravity: genericExporter,
+  pi: genericExporter,
+  grok: genericExporter,
+};
+
+export function getExporter(target: ExportTarget): HarnessExporter {
+  const exporter = exporters[target];
+  if (!exporter) {
+    throw new Error(`No exporter for target: ${target}`);
+  }
+  return exporter;
+}
+
+function manifestPathFor(outputPath: string): string {
+  if (outputPath.toLowerCase().endsWith(".jsonl")) {
+    return `${outputPath.slice(0, -".jsonl".length)}.manifest.json`;
+  }
+  return `${outputPath}.manifest.json`;
+}
+
+export async function exportSession(
+  sessionId: string,
+  target?: ExportTarget,
+  outputPath?: string,
+): Promise<{
+  content: string;
+  outputPath: string | null;
+  manifestPath: string | null;
+  manifest: ExportManifest;
+}> {
+  const events = await getSessionEvents(sessionId);
+  if (events.length === 0) {
+    throw new Error(`No events found for session ${sessionId}`);
+  }
+
+  const resolvedTarget = target ?? events[0]!.source;
+  const exporter = getExporter(resolvedTarget);
+  const result = exporter.export({
+    sessionId,
+    source: events[0]!.source,
+    sourceSessionId: events[0]!.sourceSessionId,
+    events,
+  });
+
+  const content = result.lines.length > 0 ? `${result.lines.join("\n")}\n` : "";
+
+  const manifest: ExportManifest = {
+    source: events[0]!.source,
+    target: resolvedTarget,
+    sessionId,
+    sourceSessionId: events[0]!.sourceSessionId,
+    lossy: result.lossy,
+    warnings: result.warnings.map((warning) => warning.message),
+    exportedAt: new Date().toISOString(),
+    lineCount: result.lines.length,
+  };
+
+  if (!outputPath) {
+    await recordExport(
+      sessionId,
+      resolvedTarget,
+      "-",
+      result.lossy,
+      manifest.warnings,
+    );
+    return { content, outputPath: null, manifestPath: null, manifest };
+  }
+
+  mkdirSync(dirname(outputPath), { recursive: true });
+  writeFileSync(outputPath, content, "utf-8");
+
+  const manifestPath = manifestPathFor(outputPath);
+  writeFileSync(
+    manifestPath,
+    `${JSON.stringify(manifest, null, 2)}\n`,
+    "utf-8",
+  );
+  await recordExport(
+    sessionId,
+    resolvedTarget,
+    outputPath,
+    result.lossy,
+    manifest.warnings,
+  );
+  return { content, outputPath, manifestPath, manifest };
+}
+
+export async function resolveSessionId(
+  source: ProviderId,
+  sourceSessionId: string,
+): Promise<string> {
+  const id = await findSessionBySourceId(source, sourceSessionId);
+  if (!id) {
+    throw new Error(
+      `Session not found in database: ${source}/${sourceSessionId}`,
+    );
+  }
+  return id;
+}

package/src/export/types.ts

@@ -0,0 +1,44 @@
+import type { ExportWarning } from "../ir/types.ts";
+import type { ProviderId } from "../ir/types.ts";
+
+export type ExportTarget = ProviderId | "generic";
+
+export interface ExportContext {
+  sessionId: string;
+  source: ProviderId;
+  sourceSessionId: string;
+  events: Array<{
+    seq: number;
+    boundary: string;
+    role: string;
+    timestamp: string;
+    contentText: string;
+    toolName: string | null;
+    toolCallId: string | null;
+    toolInputJson: string | null;
+    toolOutputJson: string | null;
+    rawJson: string;
+  }>;
+}
+
+export interface ExportResult {
+  lines: string[];
+  lossy: boolean;
+  warnings: ExportWarning[];
+}
+
+export interface HarnessExporter {
+  target: ExportTarget;
+  export(context: ExportContext): ExportResult;
+}
+
+export interface ExportManifest {
+  source: ProviderId;
+  target: ExportTarget;
+  sessionId: string;
+  sourceSessionId: string;
+  lossy: boolean;
+  warnings: string[];
+  exportedAt: string;
+  lineCount: number;
+}