papilot 0.6.0 → 0.8.0

package/vendor/latex-review/src/core/build.ts

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { createHash } from "node:crypto";
+import { createHash, randomUUID } from "node:crypto";
 import { fileURLToPath } from "node:url";
 import { Repo } from "./git.ts";
 import { listFiles, readJson, writeJson, withLock, now } from "./files.ts";
@@ -197,6 +197,7 @@ export class Builder {
     rev: string,
     targets = ["full"],
     seed: BuildInfo | null = null,
+    options: { force?: boolean } = {},
   ): Promise<BuildInfo> {
     const p = this.project,
       partial = JSON.stringify(targets) !== '["full"]';
@@ -223,6 +224,9 @@ export class Builder {
           version,
           date,
           hash(fs.readFileSync(fileURLToPath(import.meta.url))),
+          // Manual recompilation gets a fresh output directory. Other previews
+          // and review rounds may still be reading the previous cached PDF.
+          ...(options.force ? [randomUUID()] : []),
         ]),
       ).slice(0, 32),
       folder = path.join(this.cache, key);

package/vendor/latex-review/src/core/changes.ts

@@ -1,5 +1,6 @@
 import { Repo, within } from "./git.ts";
 import { groups, opcodes } from "./diff.ts";
+import { entrySpans } from "./bib.ts";
 import type { Scope, Unit, Op } from "../types.ts";
 export const EXCERPT = 6000;
 export function textOf(data: Buffer | null): string | null {
@@ -34,6 +35,8 @@ export function diffUnits(
     const left = binary ? [] : splitLines(a!),
       right = binary ? [] : splitLines(b!);
     let hunks = binary ? [] : groups(opcodes(left, right));
+    if (!binary && file.endsWith(".bib"))
+      hunks = byEntry(hunks, entrySpans(a!), entrySpans(b!));
     const whole =
       binary || status !== "modified" || isFigure(file) || !hunks.length;
     if (whole) hunks = [[["replace", 0, left.length, 0, right.length]]];
@@ -61,6 +64,42 @@ export function diffUnits(
   }
   return units;
 }
+// A bibliography entry is decided whole: hunks that touch the same entry,
+// before or after, or the same key on either side, become one change, so
+// accepting part of an entry cannot mix its old and new fields.
+export function byEntry(
+  hunks: Op[][],
+  before: { key: string; span: [number, number] }[],
+  after: { key: string; span: [number, number] }[],
+) {
+  // An empty range touches an entry it falls strictly inside.
+  const touches = ([a, b]: [number, number], [s, e]: [number, number]) =>
+    a === b ? s < a && a < e : a < e && s < b;
+  const root = hunks.map((_, i) => i),
+    find = (i: number): number => (root[i] === i ? i : (root[i] = find(root[i]))),
+    owner = new Map<string, number>();
+  hunks.forEach((hunk, i) => {
+    const old: [number, number] = [hunk[0][1], hunk.at(-1)![2]],
+      next: [number, number] = [hunk[0][3], hunk.at(-1)![4]],
+      keys = [
+        ...before.filter((e) => touches(old, e.span)).map((e) => e.key),
+        ...after.filter((e) => touches(next, e.span)).map((e) => e.key),
+      ];
+    for (const key of keys) {
+      const j = owner.get(key);
+      if (j === undefined) owner.set(key, i);
+      else root[find(i)] = find(j);
+    }
+  });
+  const merged = new Map<number, Op[]>();
+  hunks.forEach((hunk, i) => {
+    const r = find(i);
+    merged.set(r, [...(merged.get(r) ?? []), ...hunk]);
+  });
+  return [...merged.values()].map((ops) =>
+    ops.sort((p, q) => p[1] - q[1] || p[3] - q[3]),
+  );
+}
 function edits(units: Unit[], index: 1 | 3): Op[] {
   return units.flatMap((u) => u.ops).sort((a, b) => b[index] - a[index]);
 }

package/vendor/latex-review/src/core/delivery.ts

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import path from "node:path";
+import type { App } from "../server.ts";
+import type { Delivery } from "../types.ts";
+import { merge3 } from "./git.ts";
+import { readBytes, same, writeOrDelete } from "./files.ts";
+import { safePath } from "./review.ts";
+
+const encode = (data: Buffer | null) => data?.toString("base64") ?? null;
+const decode = (data: string | null) => data === null ? null : Buffer.from(data, "base64");
+
+// Acceptance stays in Git objects until the author chooses a destination.
+// Persist the exact intended result before touching files or a branch so a
+// lost response or a restart can finish the same operation without duplication.
+export class Deliveries {
+  constructor(public app: App) {}
+  get(name: string) {
+    return this.app.store.one<{ data: Delivery }>("SELECT data FROM deliveries WHERE task=?", name)?.data;
+  }
+  save(name: string, data: Delivery) {
+    this.app.store.execute("INSERT OR REPLACE INTO deliveries(task,data) VALUES(?,?)", name, JSON.stringify(data));
+  }
+  assertReady(name: string) {
+    const last = this.get(name);
+    if (last && !last.done) throw new Error("Finish the pending delivery before changing this review. Retry the same destination.");
+  }
+  deliver(name: string, mode: Delivery["mode"], message = "") {
+    const app = this.app, task = app.tasks.get(name), last = this.get(name);
+    if (!task.deferred) throw new Error("This task already applies accepted changes to the manuscript.");
+    if (mode !== "workspace" && mode !== "branch") throw new Error("Choose a working directory or task branch.");
+    if (last && last.mode !== mode) throw new Error("Continue using this task's original destination, or start a new task.");
+    if (last && (!last.done || last.accepted === task.accepted)) return this.finish(name, last);
+    if (app.publisher.busy(name) || app.review.counts(name).pending) throw new Error("Finish reviewing every change before choosing a destination.");
+    const before = last?.accepted ?? task.base;
+    const files = app.repo.changedFiles(before, task.accepted);
+    if (!files.length) throw new Error("This task has no accepted changes left to deliver.");
+    const base = app.repo.blobs(before, files), accepted = app.repo.blobs(task.accepted, files);
+    const data: Delivery = { mode, accepted: task.accepted, seq: app.store.one<{ seq: number }>("SELECT MAX(seq) AS seq FROM actions WHERE task=?", name)!.seq, done: false, writes: [] };
+    const contents: Record<string, Buffer | null> = {};
+    let current: Record<string, Buffer | null>;
+    if (mode === "branch") {
+      if (!message.trim() || message.length > 5000) throw new Error("Write a commit message (at most 5,000 characters).");
+      data.branch = `papilot/${name}`;
+      data.previous = last?.commit;
+      // The base snapshot may include the author's uncommitted edits. Apply
+      // only the accepted delta onto its original HEAD, never commit those edits.
+      data.parent = last?.commit ?? app.repo.rev(`${task.base}^`);
+      current = app.repo.blobs(data.parent, files);
+      const ref = app.repo.text(["show-ref", "--verify", "--hash", `refs/heads/${data.branch}`], { check: false });
+      if (ref !== (data.previous ?? "")) throw new Error("The task branch was changed outside Papilot. Nothing was committed.");
+      this.assertBranchAvailable(data.branch);
+    } else {
+      this.assertNoMerge();
+      current = Object.fromEntries(files.map(file => [file, readBytes(safePath(app.root, file))]));
+    }
+    for (const file of files) {
+      const [merged, conflict] = merge3(current[file], base[file], accepted[file]);
+      if (conflict) throw new Error(`Cannot deliver ${file}: it conflicts with the destination. Nothing was written. Revise the task and try again.`);
+      contents[file] = merged;
+      if (mode === "workspace" && !same(current[file], merged)) data.writes.push({ file, before: encode(current[file]), after: encode(merged) });
+    }
+    if (mode === "branch") {
+      const tree = app.repo.treeWith(data.parent!, contents);
+      data.commit = app.repo.text(["commit-tree", tree, "-p", data.parent!, "-m", message.trim()]);
+    }
+    this.save(name, data);
+    return this.finish(name, data);
+  }
+  private assertBranchAvailable(branch: string) {
+    if (this.app.repo.text(["worktree", "list", "--porcelain"]).split("\n").includes(`branch refs/heads/${branch}`))
+      throw new Error("The task branch is checked out. Switch that worktree to another branch before committing here.");
+  }
+  private assertNoMerge() {
+    if (fs.existsSync(path.resolve(this.app.root, this.app.repo.text(["rev-parse", "--git-path", "MERGE_HEAD"]))))
+      throw new Error("Finish or abort the merge before applying changes.");
+  }
+  finish(name: string, data: Delivery) {
+    if (data.done) return this.result(data);
+    const app = this.app;
+    if (data.mode === "branch") {
+      const ref = `refs/heads/${data.branch}`;
+      const current = app.repo.text(["show-ref", "--verify", "--hash", ref], { check: false });
+      if (current !== data.commit) {
+        this.assertBranchAvailable(data.branch!);
+        app.repo.run(["update-ref", ref, data.commit!, data.previous ?? "0".repeat(data.commit!.length)]);
+      }
+    } else {
+      this.assertNoMerge();
+      const writes = data.writes.map(write => ({ ...write, target: safePath(app.root, write.file) }));
+      for (const write of writes) {
+        const current = readBytes(write.target);
+        if (!same(current, decode(write.before)) && !same(current, decode(write.after)))
+          throw new Error(`Cannot finish delivery: ${write.file} changed. Restore it to its state before delivery and retry.`);
+      }
+      for (const write of writes) writeOrDelete(write.target, decode(write.after));
+    }
+    this.save(name, { ...data, done: true, writes: [] });
+    return this.result(data);
+  }
+  result(data: Delivery) {
+    const { mode, accepted, branch, commit } = data;
+    return { mode, accepted, ...(branch ? { branch, commit } : {}) };
+  }
+  recover() {
+    for (const row of this.app.store.all<{ task: string; data: Delivery }>("SELECT * FROM deliveries")) {
+      if (!row.data.done) try { this.finish(row.task, row.data); } catch { /* Retain the journal for an explicit retry. */ }
+    }
+  }
+}

package/vendor/latex-review/src/core/review.ts

@@ -121,7 +121,8 @@ export class Review {
         "SELECT * FROM actions WHERE task=? AND status='applied' ORDER BY seq DESC LIMIT 1",
         name,
       );
-    return action && latest && action.round === latest.number ? action : null;
+    const delivered = this.app.delivery.get(name);
+    return action && latest && action.round === latest.number && (!delivered || action.seq > delivered.seq) ? action : null;
   }
   summary(name: string): Summary {
     const task = this.app.tasks.get(name),
@@ -199,6 +200,10 @@ export class Review {
       closed: Boolean(task.closed),
       state: task.closed ? null : this.summary(name).state,
       latest: latest?.number ?? null,
+      history: this.app.store.all<{ number: number; created: number }>(
+        "SELECT number,created FROM rounds WHERE task=? ORDER BY number DESC",
+        name,
+      ),
       round: number ?? null,
       revision: round?.after ?? null,
       decisions: round ? this.decisions(name, round) : {},
@@ -256,6 +261,7 @@ export class Review {
       loose: render.loose,
       warnings: round.summary.warnings ?? [],
       files: `/files/${name}/${number}/`,
+      ...(render.references ? { references: render.references } : {}),
     };
   }
   history(name: string, round: Round): Record<string, History[]> {
@@ -360,6 +366,7 @@ export class Review {
   ) {
     const task = this.app.tasks.get(name),
       kind = data.action;
+    this.app.delivery.assertReady(name);
     if (!Object.hasOwn(DECIDED, kind))
       throw new Error("The action must be accept, reject or comment.");
     const identity = data.id || randomUUID();
@@ -440,8 +447,8 @@ export class Review {
       records = app.repo.blobs(task.accepted, files);
     for (const [file, group] of Object.entries(groups)) {
       const proposed = applyUnits(before[file], after[file], group),
-        target = safePath(app.root, file),
-        current = readBytes(target),
+        target = task.deferred ? "" : safePath(app.root, file),
+        current = task.deferred ? records[file] : readBytes(target),
         [merged, conflict] = merge3(current, before[file], proposed),
         [recorded, recordedConflict] = merge3(
           records[file],
@@ -449,7 +456,7 @@ export class Review {
           proposed,
         );
       if (conflict || recordedConflict) conflicts.push(file);
-      else if (!same(merged, current)) writes.push([target, current, merged]);
+      else if (!task.deferred && !same(merged, current)) writes.push([target, current, merged]);
       accepted[file] = recorded;
     }
     if (conflicts.length)
@@ -672,6 +679,7 @@ export class Review {
     return this.pageState(name);
   }
   undo(name: string, identity: string) {
+    this.app.delivery.assertReady(name);
     const app = this.app,
       task = app.tasks.get(name),
       action = this.undoEntry(name);

package/vendor/latex-review/src/core/store.ts

@@ -3,6 +3,7 @@ import fs from "node:fs";
 import path from "node:path";
 const SCHEMA = `
 CREATE TABLE IF NOT EXISTS tasks(name TEXT PRIMARY KEY,title TEXT NOT NULL,worktree TEXT NOT NULL,base TEXT NOT NULL,accepted TEXT NOT NULL,scope TEXT NOT NULL,created REAL NOT NULL,closed REAL);
+CREATE TABLE IF NOT EXISTS deliveries(task TEXT PRIMARY KEY,data TEXT NOT NULL);
 CREATE TABLE IF NOT EXISTS rounds(task TEXT NOT NULL,number INTEGER NOT NULL,before TEXT NOT NULL,after TEXT NOT NULL,units TEXT NOT NULL,summary TEXT NOT NULL,created REAL NOT NULL,PRIMARY KEY(task,number));
 CREATE TABLE IF NOT EXISTS actions(seq INTEGER PRIMARY KEY AUTOINCREMENT,id TEXT NOT NULL UNIQUE,task TEXT NOT NULL,round INTEGER NOT NULL,kind TEXT NOT NULL,changes TEXT NOT NULL,body TEXT NOT NULL DEFAULT '',status TEXT NOT NULL,detail TEXT NOT NULL DEFAULT '{}',created REAL NOT NULL);
 CREATE TABLE IF NOT EXISTS writes(action TEXT NOT NULL,phase TEXT NOT NULL,path TEXT NOT NULL,expected BLOB,target BLOB,PRIMARY KEY(action,phase,path));
@@ -36,6 +37,8 @@ export class Store {
     this.db = new DatabaseSync(file);
     this.db.exec("PRAGMA busy_timeout=30000; PRAGMA journal_mode=WAL;");
     this.db.exec(SCHEMA);
+    if (!this.all<{ name: string }>("PRAGMA table_info(tasks)").some(column => column.name === "deferred"))
+      this.db.exec("ALTER TABLE tasks ADD COLUMN deferred INTEGER NOT NULL DEFAULT 0");
   }
   transaction<T>(work: () => T): T {
     this.db.exec("BEGIN IMMEDIATE");

package/vendor/latex-review/src/core/tasks.ts

@@ -78,6 +78,7 @@ export class Tasks {
     title?: string,
     sections: string[] = [],
     files: string[] = [],
+    deferred = false,
   ): Task {
     const { app } = this,
       project = app.project;
@@ -154,10 +155,10 @@ export class Tasks {
           name,
         );
         app.store.execute("DELETE FROM tasks WHERE name=?", name);
-        for (const table of ["rounds", "actions", "messages", "jobs"])
+        for (const table of ["rounds", "actions", "messages", "jobs", "deliveries"])
           app.store.execute(`DELETE FROM ${table} WHERE task=?`, name);
         app.store.execute(
-          "INSERT INTO tasks(name,title,worktree,base,accepted,scope,created) VALUES(?,?,?,?,?,?,?)",
+          "INSERT INTO tasks(name,title,worktree,base,accepted,scope,created,deferred) VALUES(?,?,?,?,?,?,?,?)",
           name,
           title,
           worktree,
@@ -165,6 +166,7 @@ export class Tasks {
           base,
           JSON.stringify(scope),
           now(),
+          Number(deferred),
         );
       });
     } catch (error) {
@@ -196,6 +198,7 @@ export class Tasks {
     );
   }
   async finish(name: string, force = false) {
+    this.app.delivery.assertReady(name);
     const app = this.app,
       task = this.get(name);
     if (app.publisher.busy(name))