@gmickel/gno 1.31.0 → 1.32.0

package/src/store/sqlite/file-refactor-journal-store.ts

@@ -0,0 +1,275 @@
+/**
+ * SQLite persistence for content-free file-refactor recovery receipts.
+ *
+ * @module src/store/sqlite/file-refactor-journal-store
+ */
+
+import type { Database } from "bun:sqlite";
+
+import type { FileRefactorOperation } from "../../core/file-refactor-contract";
+import type {
+  FileRefactorJournalAdvance,
+  FileRefactorJournalFileEntry,
+  FileRefactorJournalFilesystemState,
+  FileRefactorJournalIndexState,
+  FileRefactorJournalPhase,
+  FileRefactorRecoveryReceipt,
+  FileRefactorRecoveryReceiptDraft,
+} from "../../core/file-refactor-journal";
+import type { StoreResult } from "../types";
+
+import {
+  assertAllowedJournalPhaseTransition,
+  FILE_REFACTOR_JOURNAL_MAX_RECEIPTS,
+  FILE_REFACTOR_JOURNAL_PHASE_ORDINAL,
+  parseFileRefactorJournalFileEntries,
+} from "../../core/file-refactor-journal";
+import { err, ok } from "../types";
+
+interface DbRow {
+  journal_id: string;
+  plan_digest: string;
+  collection: string;
+  operation: FileRefactorOperation;
+  source_rel_path: string;
+  target_rel_path: string;
+  phase: FileRefactorJournalPhase;
+  phase_ordinal: number;
+  filesystem_state: FileRefactorJournalFilesystemState;
+  index_state: FileRefactorJournalIndexState;
+  file_entries_json: string;
+  created_at_ms: number;
+  updated_at_ms: number;
+}
+
+const mapRow = (row: DbRow): FileRefactorRecoveryReceipt => ({
+  journalId: row.journal_id,
+  planDigest: row.plan_digest,
+  collection: row.collection,
+  operation: row.operation,
+  sourceRelPath: row.source_rel_path,
+  targetRelPath: row.target_rel_path,
+  phase: row.phase,
+  phaseOrdinal: row.phase_ordinal,
+  filesystemState: row.filesystem_state,
+  indexState: row.index_state,
+  fileEntries: parseFileRefactorJournalFileEntries(row.file_entries_json),
+  createdAtMs: row.created_at_ms,
+  updatedAtMs: row.updated_at_ms,
+});
+
+const assertContentFreeEntries = (
+  entries: FileRefactorJournalFileEntry[]
+): void => {
+  const serialized = JSON.stringify(entries);
+  if (serialized.length > 65_536) {
+    throw new RangeError("File refactor journal entries exceed size bound");
+  }
+  parseFileRefactorJournalFileEntries(entries);
+};
+
+const pruneOldestTerminalReceipts = (db: Database): void => {
+  const countRow = db
+    .query<{ count: number }, []>(
+      `SELECT COUNT(*) AS count FROM file_refactor_recovery_journal`
+    )
+    .get();
+  const count = countRow?.count ?? 0;
+  if (count < FILE_REFACTOR_JOURNAL_MAX_RECEIPTS) return;
+
+  const overflow = count - FILE_REFACTOR_JOURNAL_MAX_RECEIPTS + 1;
+  db.run(
+    `DELETE FROM file_refactor_recovery_journal
+     WHERE journal_id IN (
+       SELECT journal_id FROM file_refactor_recovery_journal
+       WHERE phase IN ('converged', 'rolled_back', 'aborted')
+       ORDER BY updated_at_ms ASC, journal_id ASC
+       LIMIT ?
+     )`,
+    [overflow]
+  );
+
+  const after = db
+    .query<{ count: number }, []>(
+      `SELECT COUNT(*) AS count FROM file_refactor_recovery_journal`
+    )
+    .get();
+  if ((after?.count ?? 0) >= FILE_REFACTOR_JOURNAL_MAX_RECEIPTS) {
+    throw new Error(
+      "File refactor journal at capacity with no prunable terminal receipts"
+    );
+  }
+};
+
+export const createFileRefactorPreparedReceipt = (
+  db: Database,
+  draft: FileRefactorRecoveryReceiptDraft
+): StoreResult<FileRefactorRecoveryReceipt> => {
+  try {
+    assertContentFreeEntries(draft.fileEntries);
+    pruneOldestTerminalReceipts(db);
+    const phase: FileRefactorJournalPhase = "prepared";
+    const phaseOrdinal = FILE_REFACTOR_JOURNAL_PHASE_ORDINAL[phase];
+    const fileEntriesJson = JSON.stringify(draft.fileEntries);
+    db.run(
+      `INSERT INTO file_refactor_recovery_journal (
+         journal_id, plan_digest, collection, operation,
+         source_rel_path, target_rel_path, phase, phase_ordinal,
+         filesystem_state, index_state, file_entries_json,
+         created_at_ms, updated_at_ms
+       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'unchanged', 'not_attempted', ?, ?, ?)`,
+      [
+        draft.journalId,
+        draft.planDigest,
+        draft.collection,
+        draft.operation,
+        draft.sourceRelPath,
+        draft.targetRelPath,
+        phase,
+        phaseOrdinal,
+        fileEntriesJson,
+        draft.createdAtMs,
+        draft.createdAtMs,
+      ]
+    );
+    const row = db
+      .query<DbRow, [string]>(
+        `SELECT * FROM file_refactor_recovery_journal WHERE journal_id = ?`
+      )
+      .get(draft.journalId);
+    if (!row) {
+      return err("QUERY_FAILED", "Failed to read created refactor receipt");
+    }
+    return ok(mapRow(row));
+  } catch (cause) {
+    return err(
+      cause instanceof RangeError ||
+        (cause instanceof Error && cause.message.includes("Corrupt"))
+        ? "INVALID_INPUT"
+        : "QUERY_FAILED",
+      cause instanceof Error
+        ? cause.message
+        : "Failed to create file refactor recovery receipt",
+      cause
+    );
+  }
+};
+
+export const advanceFileRefactorReceipt = (
+  db: Database,
+  journalId: string,
+  update: FileRefactorJournalAdvance
+): StoreResult<FileRefactorRecoveryReceipt> => {
+  try {
+    const existing = db
+      .query<DbRow, [string]>(
+        `SELECT * FROM file_refactor_recovery_journal WHERE journal_id = ?`
+      )
+      .get(journalId);
+    if (!existing) {
+      return err(
+        "NOT_FOUND",
+        `Refactor recovery receipt not found: ${journalId}`
+      );
+    }
+    assertAllowedJournalPhaseTransition(existing.phase, update.phase);
+    if (update.updatedAtMs < existing.updated_at_ms) {
+      return err("INVALID_INPUT", "Journal updatedAtMs must be monotonic");
+    }
+    const fileEntries =
+      update.fileEntries ??
+      parseFileRefactorJournalFileEntries(existing.file_entries_json);
+    assertContentFreeEntries(fileEntries);
+    const phaseOrdinal = FILE_REFACTOR_JOURNAL_PHASE_ORDINAL[update.phase];
+    const filesystemState = update.filesystemState ?? existing.filesystem_state;
+    const indexState = update.indexState ?? existing.index_state;
+    db.run(
+      `UPDATE file_refactor_recovery_journal
+       SET phase = ?,
+           phase_ordinal = ?,
+           filesystem_state = ?,
+           index_state = ?,
+           file_entries_json = ?,
+           updated_at_ms = ?
+       WHERE journal_id = ?`,
+      [
+        update.phase,
+        phaseOrdinal,
+        filesystemState,
+        indexState,
+        JSON.stringify(fileEntries),
+        update.updatedAtMs,
+        journalId,
+      ]
+    );
+    const row = db
+      .query<DbRow, [string]>(
+        `SELECT * FROM file_refactor_recovery_journal WHERE journal_id = ?`
+      )
+      .get(journalId);
+    if (!row) {
+      return err("QUERY_FAILED", "Failed to read updated refactor receipt");
+    }
+    return ok(mapRow(row));
+  } catch (cause) {
+    return err(
+      cause instanceof RangeError ||
+        (cause instanceof Error &&
+          (cause.message.includes("Corrupt") ||
+            cause.message.includes("Invalid journal phase")))
+        ? "INVALID_INPUT"
+        : "QUERY_FAILED",
+      cause instanceof Error
+        ? cause.message
+        : "Failed to advance file refactor recovery receipt",
+      cause
+    );
+  }
+};
+
+export const getFileRefactorReceiptById = (
+  db: Database,
+  journalId: string
+): StoreResult<FileRefactorRecoveryReceipt | null> => {
+  try {
+    const row = db
+      .query<DbRow, [string]>(
+        `SELECT * FROM file_refactor_recovery_journal WHERE journal_id = ?`
+      )
+      .get(journalId);
+    return ok(row ? mapRow(row) : null);
+  } catch (cause) {
+    return err(
+      "QUERY_FAILED",
+      cause instanceof Error
+        ? cause.message
+        : "Failed to load file refactor recovery receipt",
+      cause
+    );
+  }
+};
+
+export const getLatestFileRefactorReceiptByPlanDigest = (
+  db: Database,
+  planDigest: string
+): StoreResult<FileRefactorRecoveryReceipt | null> => {
+  try {
+    const row = db
+      .query<DbRow, [string]>(
+        `SELECT * FROM file_refactor_recovery_journal
+         WHERE plan_digest = ?
+         ORDER BY updated_at_ms DESC, journal_id DESC
+         LIMIT 1`
+      )
+      .get(planDigest);
+    return ok(row ? mapRow(row) : null);
+  } catch (cause) {
+    return err(
+      "QUERY_FAILED",
+      cause instanceof Error
+        ? cause.message
+        : "Failed to lookup file refactor recovery receipt",
+      cause
+    );
+  }
+};

package/src/store/types.ts

@@ -14,6 +14,11 @@ import type {
 } from "../config/types";
 import type { RecordAnchor, RecordMetadata } from "../converters/types";
 import type { EgressLineage } from "../core/egress-provenance";
+import type {
+  FileRefactorJournalAdvance,
+  FileRefactorRecoveryReceipt,
+  FileRefactorRecoveryReceiptDraft,
+} from "../core/file-refactor-journal";
 
 // ─────────────────────────────────────────────────────────────────────────────
 // Error Types
@@ -249,6 +254,52 @@ export interface DocLinkRow {
   source: DocLinkSource;
 }
 
+/**
+ * Bounded read snapshot for reference-safe rename/move planning.
+ * Content covers indexed backlinks unioned with a conservative content
+ * prefilter (opaque embeds/HTML/code/malformed may not be in doc_links).
+ * Never logged by callers.
+ */
+export interface FileRefactorResolutionCatalogDocument {
+  id: number;
+  uri: string;
+  relPath: string;
+  collection: string;
+  title: string | null;
+}
+
+export interface FileRefactorResolutionReferrerDocument extends FileRefactorResolutionCatalogDocument {
+  /** Markdown body when available; null when mirror content is missing. */
+  content: string | null;
+  contentTruncated: boolean;
+  /** True when a potentially relevant document had no loadable mirror. */
+  contentMissing: boolean;
+  editable: boolean;
+  editableReason?: string;
+  sourceExt: string;
+  sourceMime: string;
+  recordKey: string | null;
+}
+
+export interface FileRefactorResolutionSnapshot {
+  source: FileRefactorResolutionCatalogDocument & {
+    mirrorHash: string | null;
+    sourceExt: string;
+    sourceMime: string;
+    recordKey: string | null;
+    content: string | null;
+    contentTruncated: boolean;
+    editable: boolean;
+    editableReason?: string;
+  };
+  catalog: FileRefactorResolutionCatalogDocument[];
+  referrers: FileRefactorResolutionReferrerDocument[];
+  occupiedRelPaths: string[];
+  truncated: boolean;
+  /** Content-free truncation reason codes. */
+  truncationReasons: string[];
+}
+
 /** Semantic document edge row from DB. */
 export interface DocEdgeRow {
   sourceDocId: number;
@@ -1710,6 +1761,27 @@ export interface StorePort {
   /** Purge the journal while retaining a cursor-expiry boundary. */
   purgeDocumentChanges(): Promise<StoreResult<DocumentChangePurgeResult>>;
 
+  /** Create a content-free prepared file-refactor recovery receipt. */
+  createFileRefactorPreparedReceipt(
+    draft: FileRefactorRecoveryReceiptDraft
+  ): Promise<StoreResult<FileRefactorRecoveryReceipt>>;
+
+  /** Advance phase/state on a file-refactor recovery receipt. */
+  advanceFileRefactorReceipt(
+    journalId: string,
+    update: FileRefactorJournalAdvance
+  ): Promise<StoreResult<FileRefactorRecoveryReceipt>>;
+
+  /** Load one file-refactor recovery receipt by journal id. */
+  getFileRefactorReceiptById(
+    journalId: string
+  ): Promise<StoreResult<FileRefactorRecoveryReceipt | null>>;
+
+  /** Latest receipt for a plan digest (deterministic retry/recovery lookup). */
+  getLatestFileRefactorReceiptByPlanDigest(
+    planDigest: string
+  ): Promise<StoreResult<FileRefactorRecoveryReceipt | null>>;
+
   /** Register one user-owned Capsule file and its metadata-only evidence refs. */
   upsertSavedCapsuleRegistration(
     input: SavedCapsuleRegistrationInput
@@ -1946,6 +2018,18 @@ export interface StorePort {
     >
   >;
 
+  /**
+   * Bounded resolution/inventory snapshot for reference-safe rename/move planning.
+   * Read-only: never mutates documents, links, or content.
+   */
+  getFileRefactorResolutionSnapshot?(input: {
+    sourceUri: string;
+    maxCatalogDocuments?: number;
+    maxReferrerDocuments?: number;
+    maxContentCharsPerDocument?: number;
+    maxTotalContentChars?: number;
+  }): Promise<StoreResult<FileRefactorResolutionSnapshot>>;
+
   /**
    * Set semantic edges for a document.
    * Replaces edges from the given source.

package/browser-extension/artifacts/gno-browser-clipper-v1.31.0.zip.sha256

@@ -1 +0,0 @@
-01281ef03fe26195c824909c53eed8d04ede0f9a2da72f3c4c19d7e1564e0a0c  gno-browser-clipper-v1.31.0.zip