app/lib/books.server.ts

Functions

Imports

It imports app/db/schema.ts, app/lib/ai.server.ts, app/lib/novels/checks.ts, app/lib/novels/frontmatter.ts, app/lib/novels/layout.ts, app/lib/novels/repo.server.ts, app/lib/people.server.ts, app/lib/roles.ts, app/lib/writing.server.ts. Imported by app/lib/binder.server.ts, app/lib/book-history.server.ts, app/lib/mcp/tools.ts, app/lib/novels/export.ts, app/lib/writing.server.ts, app/routes/book.authorship.ts, app/routes/book.chapter.tsx, app/routes/book.corkboard.tsx, app/routes/book.export.ts, app/routes/book.file.tsx, app/routes/book.history.tsx, app/routes/book.new.tsx, app/routes/book.outliner.tsx, app/routes/book.tsx.

Source

1// Books in the writing repository (design stage 4): the book behind a URL, Carrel's index of its
2// files, a save that commits to Git with the version it expects to replace, the checks that run on
3// every save, their findings, and the authorship record. Roles are checked here, not only in the
4// routes, so every door (the UI now, MCP tools in stage 5) is held to the same rule.
5
6import { and, asc, desc, eq, inArray, like, notInArray } from "drizzle-orm";
7import { drizzle } from "drizzle-orm/d1";
8
9import { aiDrafts, authorship, bookFiles, drafts, findings, novelsShared, people, projects } from "~/db/schema";
10import { AiRefusal, type AiSession } from "~/lib/ai.server";
11import { requireAction, type Viewer } from "~/lib/people.server";
12import { can, type Action, type Role } from "~/lib/roles";
13import { checkFile, fingerprints, readHabits, type BookContext, type Finding } from "~/lib/novels/checks";
14import { parseFile } from "~/lib/novels/frontmatter";
15import { describe, isBookFolder, isBookPath, kindOf, readingOrder, titleFromSegment, type Meta } from "~/lib/novels/layout";
16import { GitConflict, novelsConnection, novelsRepo, type NovelsRepo } from "~/lib/novels/repo.server";
17import { profileOf } from "@dustinedwards/site-runtime/prose";
18import { takeUntyped } from "~/lib/writing.server";
19
20export type BookProject = { id: number; slug: string; name: string; book: string; role: Role };
21
22function forbid(): never {
23  throw new Response("Forbidden", { status: 403 });
24}
25
26function requireCan(project: BookProject, action: Action) {
27  if (!can(project.role, action)) forbid();
28}
29
30/** As requireSiteProject: a book that does not exist, is not shared, or is not a book all answer 404. */
31export async function requireBookProject(db: D1Database, viewer: Viewer, slug: string | undefined, action: Action): Promise<BookProject> {
32  const row = slug
33    ? await drizzle(db)
34        .select({ id: projects.id, slug: projects.slug, name: projects.name, book: projects.book, site: projects.site })
35        .from(projects)
36        .where(eq(projects.slug, slug))
37        .get()
38    : undefined;
39  if (!row) throw new Response("Not found", { status: 404 });
40  const role = await requireAction(db, viewer, row.id, action);
41  if (!row.book || row.site) throw new Response("Not found", { status: 404 });
42  return { id: row.id, slug: row.slug, name: row.name, book: row.book, role };
43}
44
45/** The repository, or why there is none yet: until the App is set up, books open read-only from the index. */
46export function bookRepo(env: Env): { repo: NovelsRepo; detail: null } | { repo: null; detail: string } {
47  const connection = novelsConnection(env);
48  if (connection.state !== "connected") return { repo: null, detail: connection.detail };
49  return { repo: novelsRepo(env), detail: null };
50}
51
52/** A new book: a project whose folder in the writing repository is `folder`. Nothing is written to Git. */
53export async function createBook(db: D1Database, viewer: Viewer, input: { name: string; folder: string }) {
54  if (!viewer.isOwner) forbid();
55  const name = input.name.trim();
56  if (!name || name.length > 120) return { ok: false as const, error: "Give the book a name of up to 120 characters." };
57  if (!isBookFolder(input.folder)) return { ok: false as const, error: "Use lower-case letters, digits and single hyphens for the folder, such as paluxy-portal." };
58  const d = drizzle(db);
59  const taken = await d
60    .select({ id: projects.id })
61    .from(projects)
62    .where(eq(projects.slug, input.folder))
63    .get();
64  if (taken) return { ok: false as const, error: `A project already uses ${input.folder}.` };
65  const clash = await d.select({ id: projects.id }).from(projects).where(eq(projects.book, input.folder)).get();
66  if (clash) return { ok: false as const, error: `Another book already uses the folder ${input.folder}.` };
67  await d.insert(projects).values({ slug: input.folder, name, book: input.folder });
68  return { ok: true as const, slug: input.folder };
69}
70
71// ---------- the index
72
73export type IndexedFile = { path: string; kind: Meta["kind"]; sha: string; meta: Meta; words: number };
74
75function parseMeta(json: string): Meta {
76  try {
77    return JSON.parse(json) as Meta;
78  } catch {
79    // A row written by an older shape: treated as a plain note until the next save re-indexes it.
80    return { kind: "note" };
81  }
82}
83
84export async function listFiles(db: D1Database, project: BookProject): Promise<IndexedFile[]> {
85  requireCan(project, "read");
86  const rows = await drizzle(db)
87    .select({ path: bookFiles.path, kind: bookFiles.kind, sha: bookFiles.sha, meta: bookFiles.meta, words: bookFiles.words })
88    .from(bookFiles)
89    .where(eq(bookFiles.projectId, project.id))
90    .orderBy(asc(bookFiles.path))
91    .all();
92  return rows.map((r) => ({ ...r, meta: parseMeta(r.meta) }));
93}
94
95export async function indexedFile(db: D1Database, project: BookProject, path: string) {
96  requireCan(project, "read");
97  const row = await drizzle(db)
98    .select({ source: bookFiles.source, sha: bookFiles.sha, syncedAt: bookFiles.syncedAt })
99    .from(bookFiles)
100    .where(and(eq(bookFiles.projectId, project.id), eq(bookFiles.path, path)))
101    .get();
102  return row ?? null;
103}
104
105async function indexFile(db: D1Database, projectId: number, path: string, file: { source: string; sha: string }, now: string) {
106  const { meta, words } = describe(path, file.source);
107  const values = { kind: kindOf(path), sha: file.sha, source: file.source, meta: JSON.stringify(meta), words, syncedAt: now };
108  await drizzle(db)
109    .insert(bookFiles)
110    .values({ projectId, path, ...values })
111    .onConflictDoUpdate({ target: [bookFiles.projectId, bookFiles.path], set: values });
112}
113
114/** The context every check reads, from D1 alone, so a save costs no extra Git calls. */
115async function bookContext(db: D1Database, projectId: number): Promise<BookContext> {
116  const d = drizzle(db);
117  const rows = await d
118    .select({ path: bookFiles.path, meta: bookFiles.meta })
119    .from(bookFiles)
120    .where(and(eq(bookFiles.projectId, projectId), inArray(bookFiles.kind, ["scene", "character", "place", "rule"])))
121    .all();
122  const context: BookContext = { bible: { characters: [], places: [], rules: [] }, scenes: [], habits: readHabits(null), voice: null };
123  for (const row of rows) {
124    const meta = parseMeta(row.meta);
125    if (meta.kind === "scene") context.scenes.push({ path: row.path, header: meta.header });
126    else if (meta.kind === "character") context.bible.characters.push(meta.entry);
127    else if (meta.kind === "place") context.bible.places.push(meta.entry);
128    else if (meta.kind === "rule") context.bible.rules.push(meta.entry);
129  }
130  const shared = await d.select({ path: novelsShared.path, source: novelsShared.source }).from(novelsShared).all();
131  const habits = shared.find((s) => s.path === "shared/checks/ai-habits.md");
132  context.habits = readHabits(habits?.source ?? null);
133  context.voice = profileOf(shared.filter((s) => s.path.startsWith("shared/voice/") && !s.path.endsWith("README.md")).map((s) => parseFile(s.source).body));
134  return context;
135}
136
137// ---------- findings
138
139/**
140 * Replaces the findings for each file with what the checks found now. A dismissed finding that is
141 * found again stays dismissed; one that is no longer found is gone, whatever its state.
142 */
143/** The check names of flags added through MCP (ai.server.ts addFinding), which a recheck leaves alone. */
144const SESSION_FLAGS = ["ai", "review"];
145
146async function recordFindings(db: D1Database, projectId: number, byPath: Map<string, Finding[]>) {
147  const d = drizzle(db);
148  for (const [path, found] of byPath) {
149    const keys = await fingerprints(found);
150    // Flags a person's AI session or a reviewer added are not the checks' to withdraw.
151    const existing = await d
152      .select({ fingerprint: findings.fingerprint })
153      .from(findings)
154      .where(and(eq(findings.projectId, projectId), eq(findings.path, path), notInArray(findings.checkName, SESSION_FLAGS)))
155      .all();
156    const have = new Set(existing.map((e) => e.fingerprint));
157    const keep = new Set(keys);
158    const gone = [...have].filter((k) => !keep.has(k));
159    if (gone.length > 0) {
160      await d.delete(findings).where(and(eq(findings.projectId, projectId), eq(findings.path, path), inArray(findings.fingerprint, gone)));
161    }
162    const fresh = found.map((f, i) => ({ f, key: keys[i]! })).filter(({ key }) => !have.has(key));
163    for (const { f, key } of fresh) {
164      await d.insert(findings).values({ projectId, path, checkName: f.check, message: f.message, line: f.line, excerpt: f.excerpt, fingerprint: key });
165    }
166  }
167}
168
169/** Runs the checks over the given files (every scene when `paths` is "all") and records what they find. */
170export async function recheck(db: D1Database, projectId: number, paths: string[] | "all") {
171  if (paths !== "all" && paths.length === 0) return new Map<string, Finding[]>();
172  const context = await bookContext(db, projectId);
173  const d = drizzle(db);
174  const rows = await d
175    .select({ path: bookFiles.path, source: bookFiles.source })
176    .from(bookFiles)
177    .where(paths === "all" ? eq(bookFiles.projectId, projectId) : and(eq(bookFiles.projectId, projectId), inArray(bookFiles.path, paths)))
178    .all();
179  const byPath = new Map<string, Finding[]>();
180  for (const row of rows) byPath.set(row.path, checkFile(row.path, row.source, context));
181  await recordFindings(db, projectId, byPath);
182  return byPath;
183}
184
185export type FindingRow = {
186  id: number;
187  path: string;
188  check: string;
189  message: string;
190  line: number | null;
191  excerpt: string | null;
192  status: "open" | "dismissed";
193};
194
195export async function listFindings(db: D1Database, project: BookProject, opts: { path?: string; status?: "open" | "dismissed" } = {}): Promise<FindingRow[]> {
196  requireCan(project, "read");
197  const where = [eq(findings.projectId, project.id)];
198  if (opts.path) where.push(eq(findings.path, opts.path));
199  if (opts.status) where.push(eq(findings.status, opts.status));
200  return drizzle(db)
201    .select({
202      id: findings.id,
203      path: findings.path,
204      check: findings.checkName,
205      message: findings.message,
206      line: findings.line,
207      excerpt: findings.excerpt,
208      status: findings.status,
209    })
210    .from(findings)
211    .where(and(...where))
212    .orderBy(asc(findings.path), asc(findings.line), asc(findings.id))
213    .all();
214}
215
216/** Checks flag; a person decides. Dismissing a flag clears it for export, so it is the Owner's call. */
217export async function dismissFinding(db: D1Database, project: BookProject, viewer: Viewer, id: number, now = new Date()) {
218  requireCan(project, "publish");
219  const result = await drizzle(db)
220    .update(findings)
221    .set({ status: "dismissed", dismissedBy: viewer.id, dismissedAt: now.toISOString() })
222    .where(and(eq(findings.id, id), eq(findings.projectId, project.id)))
223    .returning({ id: findings.id });
224  if (result.length === 0) throw new Response("Not found", { status: 404 });
225}
226
227// ---------- refresh from Git
228
229export type BookRefresh = { files: number; read: number; removed: number; shared: number; more: boolean };
230
231/** How many files one refresh reads from Git; the rest wait for the next one. */
232const REFRESH_READ_CAP = 150;
233
234/**
235 * Brings the index in line with Git: files whose blob sha changed are read again, files gone from
236 * Git are dropped, and the checks run again if anything changed. Git is the authority throughout.
237 */
238export async function refreshBook(db: D1Database, repo: NovelsRepo, project: BookProject, now = new Date()): Promise<BookRefresh> {
239  requireCan(project, "read");
240  const d = drizzle(db);
241  const at = now.toISOString();
242  const [tree, sharedTree] = await Promise.all([repo.tree(project.book), repo.tree("shared")]);
243  const wanted = tree.filter((f) => isBookPath(f.path));
244  const known = new Map(
245    (await d.select({ path: bookFiles.path, sha: bookFiles.sha }).from(bookFiles).where(eq(bookFiles.projectId, project.id)).all()).map((r) => [r.path, r.sha]),
246  );
247  const stale = wanted.filter((f) => known.get(f.path) !== f.sha);
248  const batch = stale.slice(0, REFRESH_READ_CAP);
249  for (const f of batch) {
250    const file = await repo.read(`${project.book}/${f.path}`);
251    if (file) await indexFile(db, project.id, f.path, file, at);
252  }
253  const present = new Set(wanted.map((f) => f.path));
254  const removed = [...known.keys()].filter((p) => !present.has(p));
255  if (removed.length > 0) {
256    await d.delete(bookFiles).where(and(eq(bookFiles.projectId, project.id), inArray(bookFiles.path, removed)));
257    await d.delete(findings).where(and(eq(findings.projectId, project.id), inArray(findings.path, removed)));
258  }
259
260  // shared/voice/ and shared/checks/ai-habits.md, which every book's checks read.
261  const sharedWanted = sharedTree
262    .filter((f) => f.path.endsWith(".md") && (f.path.startsWith("voice/") || f.path === "checks/ai-habits.md"))
263    .map((f) => ({ path: `shared/${f.path}`, sha: f.sha }));
264  const sharedKnown = new Map((await d.select({ path: novelsShared.path, sha: novelsShared.sha }).from(novelsShared).all()).map((r) => [r.path, r.sha]));
265  let sharedRead = 0;
266  for (const f of sharedWanted) {
267    if (sharedKnown.get(f.path) === f.sha) continue;
268    const file = await repo.read(f.path);
269    if (!file) continue;
270    sharedRead++;
271    await d
272      .insert(novelsShared)
273      .values({ path: f.path, sha: file.sha, source: file.source, syncedAt: at })
274      .onConflictDoUpdate({ target: novelsShared.path, set: { sha: file.sha, source: file.source, syncedAt: at } });
275  }
276  const sharedPresent = new Set(sharedWanted.map((f) => f.path));
277  const sharedGone = [...sharedKnown.keys()].filter((p) => !sharedPresent.has(p));
278  if (sharedGone.length > 0) await d.delete(novelsShared).where(inArray(novelsShared.path, sharedGone));
279
280  if (batch.length > 0 || removed.length > 0 || sharedRead > 0 || sharedGone.length > 0) await recheck(db, project.id, "all");
281  return { files: wanted.length, read: batch.length, removed: removed.length, shared: sharedRead, more: stale.length > batch.length };
282}
283
284// ---------- saving
285
286export type BookWrite =
287  | { ok: true; version: string; commit: string; changeId: string; findings: Finding[] }
288  | { ok: false; reason: "conflict"; currentVersion: string | null; message: string }
289  | { ok: false; reason: "failed"; message: string };
290
291function wordBag(text: string): Map<string, number> {
292  const bag = new Map<string, number>();
293  for (const w of parseFile(text).body.toLowerCase().match(/[\p{L}\p{N}]+(?:['\u2019][\p{L}]+)*/gu) ?? []) bag.set(w, (bag.get(w) ?? 0) + 1);
294  return bag;
295}
296
297/**
298 * Words added and removed between two versions, counted as a multiset difference: a moved word
299 * counts as neither, a changed word as one of each. Approximate on purpose; it is a record of how
300 * much each person or AI changed, not a diff.
301 */
302export function wordDelta(before: string | null, after: string): { added: number; removed: number } {
303  const a = wordBag(before ?? "");
304  const b = wordBag(after);
305  let added = 0;
306  let removed = 0;
307  for (const [w, n] of b) added += Math.max(0, n - (a.get(w) ?? 0));
308  for (const [w, n] of a) removed += Math.max(0, n - (b.get(w) ?? 0));
309  return { added, removed };
310}
311
312/**
313 * Commits one file. The checks run on the saved text and their findings come back with the result,
314 * but no finding stops a save: a flag blocks only export. A stale expected version is refused by Git
315 * and the person's text is kept in their draft.
316 */
317export async function saveBookFile(
318  db: D1Database,
319  repo: NovelsRepo,
320  project: BookProject,
321  viewer: Viewer,
322  path: string,
323  input: {
324    source: string;
325    expectedVersion: string | null;
326    client?: string | null;
327    /** Words in this text that were not typed (pasted or dropped since the last autosave), besides those already recorded. */
328    untyped?: number;
329  },
330): Promise<BookWrite> {
331  requireCan(project, "edit");
332  if (!isBookPath(path)) throw new Response("Not found", { status: 404 });
333
334  const before = input.expectedVersion ? await indexedFile(db, project, path) : null;
335  const changeId = crypto.randomUUID();
336  let written: { sha: string; commit: string };
337  try {
338    written = await repo.write(`${project.book}/${path}`, {
339      source: input.source,
340      expectedSha: input.expectedVersion,
341      message: `Save ${project.book}/${path}\n\nCarrel-Change: ${changeId}`,
342      author: { name: viewer.name || viewer.email, email: viewer.email },
343    });
344  } catch (error) {
345    if (error instanceof GitConflict) {
346      return {
347        ok: false,
348        reason: "conflict",
349        currentVersion: error.currentSha,
350        message: "This file changed in Git since you opened it. Your text is kept here as your draft; refresh the book to see Git's version before saving.",
351      };
352    }
353    console.error(JSON.stringify({ book: "save-failed", path, error: String(error) }));
354    return { ok: false, reason: "failed", message: "Git did not accept the save. Your text is kept here as your draft." };
355  }
356
357  const d = drizzle(db);
358  // The index may not hold the version this replaced (a refresh was due); then the words are all counted as added.
359  const known = input.expectedVersion === null || (before !== null && before.sha === input.expectedVersion);
360  const delta = wordDelta(known ? (before?.source ?? null) : null, input.source);
361  // Only typed words count toward the day (ruling 6). Pastes, drops and an AI draft taken as the
362  // working draft were counted as they arrived, and come off here. An AI client's save counts for
363  // nothing, and so does a save whose starting text the index does not hold: every word would read
364  // as added.
365  const untyped = (await takeUntyped(db, project.id, viewer.id, path)) + Math.max(0, input.untyped ?? 0);
366  const wordsTyped = input.client || !known ? null : Math.max(0, delta.added - untyped);
367  await d.insert(authorship).values({
368    id: changeId,
369    projectId: project.id,
370    path,
371    personId: viewer.id,
372    client: input.client ?? null,
373    wordsAdded: delta.added,
374    wordsRemoved: delta.removed,
375    versionBefore: input.expectedVersion,
376    versionAfter: written.sha,
377    commitSha: written.commit,
378    wordsTyped,
379  });
380  await indexFile(db, project.id, path, { source: input.source, sha: written.sha }, new Date().toISOString());
381  await d.delete(drafts).where(and(eq(drafts.projectId, project.id), eq(drafts.itemId, path), eq(drafts.personId, viewer.id)));
382
383  // A bible entry can change what every scene's checks say; a scene can change its successor's timeline.
384  const kind = kindOf(path);
385  let paths: string[] | "all" = [path];
386  if (kind === "character" || kind === "place" || kind === "rule") paths = "all";
387  else if (kind === "scene") {
388    const order = readingOrder((await d.select({ path: bookFiles.path }).from(bookFiles).where(eq(bookFiles.projectId, project.id)).all()));
389    const at = order.findIndex((s) => s.path === path);
390    const next = order[at + 1];
391    if (next) paths = [path, next.path];
392  }
393  const found = await recheck(db, project.id, paths);
394  return { ok: true, version: written.sha, commit: written.commit, changeId, findings: found.get(path) ?? [] };
395}
396
397/** The checks on text that has not been saved: nothing is recorded, nothing is committed. */
398export async function checkDraft(db: D1Database, project: BookProject, path: string, source: string): Promise<Finding[]> {
399  requireCan(project, "read");
400  if (!isBookPath(path)) throw new Response("Not found", { status: 404 });
401  const context = await bookContext(db, project.id);
402  return checkFile(path, source, context);
403}
404
405// ---------- export and the authorship record
406
407/** What scripts/import-docx.mjs writes where it could not convert something. */
408const IMPORT_MARKER = "<!-- import:";
409
410/** Export sends a book out, so, like publish, it is the Owner's, and waits while any flag is open. */
411export async function exportGate(db: D1Database, project: BookProject): Promise<{ ok: true } | { ok: false; open: number; message: string }> {
412  requireCan(project, "publish");
413  const d = drizzle(db);
414  // The manuscript importer marks what it could not convert with these; none may reach a reader.
415  const marked = await d
416    .select({ path: bookFiles.path })
417    .from(bookFiles)
418    .where(and(eq(bookFiles.projectId, project.id), like(bookFiles.source, `%${IMPORT_MARKER}%`)))
419    .all();
420  if (marked.length > 0) {
421    const paths = marked.map((m) => m.path).sort();
422    return {
423      ok: false,
424      open: marked.length,
425      message: `${paths.length} file${paths.length === 1 ? " still holds" : "s still hold"} an ${IMPORT_MARKER} ... --> marker from the Word import: ${paths.join(", ")}. Fix the text there and delete each marker before exporting.`,
426    };
427  }
428  const open = await d
429    .select({ id: findings.id })
430    .from(findings)
431    .where(and(eq(findings.projectId, project.id), eq(findings.status, "open")))
432    .all();
433  if (open.length === 0) return { ok: true };
434  return {
435    ok: false,
436    open: open.length,
437    message: `${open.length} flag${open.length === 1 ? " is" : "s are"} open. Fix the text or dismiss each flag before exporting.`,
438  };
439}
440
441export type Assembled = {
442  title: string;
443  author: string;
444  language: string;
445  chapters: { slug: string; title: string; scenes: { path: string; body: string }[] }[];
446};
447
448/** The book in reading order, from the index (refresh first to export what Git holds). */
449export async function assembleBook(db: D1Database, project: BookProject, viewer: Viewer): Promise<Assembled> {
450  requireCan(project, "publish");
451  const rows = await drizzle(db)
452    .select({ path: bookFiles.path, source: bookFiles.source, meta: bookFiles.meta })
453    .from(bookFiles)
454    .where(eq(bookFiles.projectId, project.id))
455    .all();
456  const bookRow = rows.find((r) => r.path === "book.md");
457  const meta = bookRow ? parseMeta(bookRow.meta) : null;
458  const entry = meta?.kind === "book" ? meta.entry : null;
459  const chapters: Assembled["chapters"] = [];
460  for (const scene of readingOrder(rows)) {
461    const slug = scene.path.split("/")[1]!;
462    let chapter = chapters.at(-1);
463    if (!chapter || chapter.slug !== slug) {
464      chapter = { slug, title: titleFromSegment(slug), scenes: [] };
465      chapters.push(chapter);
466    }
467    chapter.scenes.push({ path: scene.path, body: parseFile(scene.source).body.trim() });
468  }
469  return { title: entry?.title || project.name, author: entry?.author || viewer.name || viewer.email, language: entry?.language || "en", chapters };
470}
471
472export type AuthorshipRow = {
473  id: string;
474  path: string;
475  who: string;
476  client: string | null;
477  wordsAdded: number;
478  wordsRemoved: number;
479  commit: string;
480  at: string;
481};
482
483export async function authorshipRecord(db: D1Database, project: BookProject): Promise<AuthorshipRow[]> {
484  requireCan(project, "read");
485  const rows = await drizzle(db)
486    .select({
487      id: authorship.id,
488      path: authorship.path,
489      name: people.name,
490      email: people.email,
491      client: authorship.client,
492      wordsAdded: authorship.wordsAdded,
493      wordsRemoved: authorship.wordsRemoved,
494      commit: authorship.commitSha,
495      at: authorship.createdAt,
496    })
497    .from(authorship)
498    .innerJoin(people, eq(people.id, authorship.personId))
499    .where(eq(authorship.projectId, project.id))
500    .orderBy(desc(authorship.createdAt))
501    .all();
502  return rows.map(({ name, email, ...r }) => ({ ...r, who: name || email }));
503}
504
505/** The record as a readable Markdown report: totals per person or AI client, then every change. */
506export function authorshipReport(project: BookProject, rows: AuthorshipRow[], now = new Date()): string {
507  const byWho = new Map<string, { changes: number; added: number; removed: number }>();
508  for (const r of rows) {
509    const who = r.client ? `${r.client} (AI, on ${r.who}'s instruction)` : r.who;
510    const t = byWho.get(who) ?? { changes: 0, added: 0, removed: 0 };
511    t.changes++;
512    t.added += r.wordsAdded;
513    t.removed += r.wordsRemoved;
514    byWho.set(who, t);
515  }
516  const lines = [
517    `# Authorship record: ${project.name}`,
518    "",
519    `Every change Carrel committed to ${project.book}/ in the writing repository, as of ${now.toISOString().slice(0, 10)}. Words are counted as added and removed between versions, so a changed word counts once each way.`,
520    "",
521    "## By person",
522    "",
523    "| Who | Changes | Words added | Words removed |",
524    "| --- | ---: | ---: | ---: |",
525    ...[...byWho].map(([who, t]) => `| ${who} | ${t.changes} | ${t.added} | ${t.removed} |`),
526    "",
527    "## Every change",
528    "",
529    "| When (UTC) | Who | File | Added | Removed | Commit |",
530    "| --- | --- | --- | ---: | ---: | --- |",
531    ...rows.map(
532      (r) =>
533        `| ${r.at.slice(0, 16).replace("T", " ")} | ${r.client ? `${r.client} (AI)` : r.who} | ${r.path} | ${r.wordsAdded} | ${r.wordsRemoved} | ${r.commit.slice(0, 7)} |`,
534    ),
535    "",
536  ];
537  return lines.join("\n");
538}
539
540/** The Carrel drafts people are working on in this book, so the book view can show them before Git has them. */
541export async function draftPaths(db: D1Database, project: BookProject, viewer: Viewer): Promise<string[]> {
542  requireCan(project, "read");
543  const rows = await drizzle(db)
544    .select({ path: drafts.itemId })
545    .from(drafts)
546    .where(and(eq(drafts.projectId, project.id), eq(drafts.personId, viewer.id)))
547    .all();
548  return rows.map((r) => r.path).filter(isBookPath);
549}
550
551/**
552 * An AI draft of a book file, saved beside the person's own and never committed (design: AI never
553 * rewrites Dustin's prose unasked). The same table as posts' AI drafts, keyed by the file's path.
554 */
555export async function saveBookAiDraft(db: D1Database, project: BookProject, session: AiSession, path: string, input: { source: string; note?: string }) {
556  if (session.viewer.isReviewer) throw new AiRefusal("A reviewer flags; it does not write text. Use carrel_add_book_finding.");
557  requireCan(project, "edit");
558  if (!isBookPath(path)) throw new Response("Not found", { status: 404 });
559  if (!input.source.trim()) throw new Response("The draft is empty.", { status: 400 });
560  const base = await indexedFile(db, project, path);
561  const [row] = await drizzle(db)
562    .insert(aiDrafts)
563    .values({
564      projectId: project.id,
565      itemId: path,
566      personId: session.viewer.id,
567      client: session.client,
568      source: input.source.replace(/\r\n/g, "\n"),
569      baseVersion: base?.sha ?? null,
570      note: (input.note ?? "").trim().slice(0, 500),
571    })
572    .returning({ id: aiDrafts.id });
573  return { id: row!.id, baseVersion: base?.sha ?? null };
574}