texlite 0.8.4 → 0.9.1

package/dist/server/commentMentions.js

@@ -0,0 +1,139 @@
+import { randomUUID } from "node:crypto";
+/**
+ * List active users who can access a project.  The owner is included even
+ * though they have no project_members row.  Callers can exclude the author
+ * when presenting a mention picker.
+ */
+export function mentionableUsersForProject(db, projectId, excludeUserId) {
+    const exclusion = excludeUserId ? "AND user.id <> ?" : "";
+    const parameters = excludeUserId ? [projectId, excludeUserId] : [projectId];
+    const rows = db.prepare(`SELECT DISTINCT user.id, user.username, user.display_name
+    FROM users user
+    JOIN projects project ON project.id = ?
+    LEFT JOIN project_members member ON member.project_id = project.id AND member.user_id = user.id
+    WHERE user.disabled = 0
+      AND (user.id = project.owner_id OR member.user_id IS NOT NULL)
+      ${exclusion}
+    ORDER BY user.display_name COLLATE NOCASE, user.username COLLATE NOCASE`)
+        .all(...parameters);
+    return rows.map((user) => ({ id: user.id, username: user.username, displayName: user.display_name }));
+}
+/**
+ * Extract mention tokens without taking ownership of ordinary `@` text.
+ * The surrounding-character rule intentionally excludes e-mail addresses;
+ * the candidate lookup below then makes a token a mention only when it is an
+ * exact, currently accessible username.
+ */
+export function mentionedUsernames(content, candidates) {
+    const available = new Map(candidates.map((candidate) => [candidate.username.toLocaleLowerCase(), candidate.username]));
+    const usernames = new Set();
+    const pattern = /(^|[^\p{L}\p{N}_.-])@([\p{L}\p{N}_.-]+)/gu;
+    for (const match of content.matchAll(pattern)) {
+        let token = match[2];
+        let username = available.get(token.toLocaleLowerCase());
+        // A sentence-ending period or comma is not part of the mention, even
+        // though a username itself is allowed to contain dots and hyphens.
+        while (!username && /[.,;:!?)}\]\u201d\u2019]$/u.test(token)) {
+            token = token.slice(0, -1);
+            username = available.get(token.toLocaleLowerCase());
+        }
+        if (username)
+            usernames.add(username);
+    }
+    return [...usernames];
+}
+/** Persist first-class notifications for exact mentions in one comment item. */
+export function createCommentMentions(db, input) {
+    const candidates = mentionableUsersForProject(db, input.projectId);
+    const previousUsernames = new Set(input.previousContent ? mentionedUsernames(input.previousContent, candidates) : []);
+    const recipients = mentionedUsernames(input.content, candidates)
+        .map((username) => candidates.find((candidate) => candidate.username === username))
+        .filter((candidate) => Boolean(candidate && candidate.id !== input.authorId && !previousUsernames.has(candidate.username)));
+    if (!recipients.length)
+        return;
+    const insert = db.prepare(`INSERT INTO comment_mentions
+    (id, project_id, comment_id, reply_id, mentioned_user_id, mentioned_by_user_id, created_at)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT DO UPDATE SET
+      mentioned_by_user_id = excluded.mentioned_by_user_id,
+      created_at = excluded.created_at,
+      read_at = NULL,
+      read_reason = NULL`);
+    for (const recipient of recipients) {
+        insert.run(randomUUID(), input.projectId, input.commentId, input.replyId ?? null, recipient.id, input.authorId, input.createdAt);
+    }
+}
+/** Return unread mention counts scoped to one receiving user. */
+export function unreadMentionCountsForProjects(db, projectIds, userId) {
+    const counts = new Map();
+    for (let offset = 0; offset < projectIds.length; offset += 200) {
+        const chunk = projectIds.slice(offset, offset + 200);
+        const placeholders = chunk.map(() => "?").join(", ");
+        const rows = db.prepare(`SELECT project_id, COUNT(*) AS count
+      FROM comment_mentions
+      WHERE mentioned_user_id = ? AND read_at IS NULL AND project_id IN (${placeholders})
+      GROUP BY project_id`).all(userId, ...chunk);
+        for (const row of rows)
+            counts.set(row.project_id, Number(row.count) || 0);
+    }
+    return counts;
+}
+function mentionFromRow(row) {
+    return {
+        id: row.id,
+        projectId: row.project_id,
+        commentId: row.comment_id,
+        replyId: row.reply_id,
+        filePath: row.file_path,
+        content: row.reply_id ? row.reply_content ?? "" : row.comment_content,
+        resolved: Boolean(row.resolved),
+        createdAt: row.created_at,
+        readAt: row.read_at,
+        readReason: row.read_reason
+    };
+}
+const mentionSelect = `SELECT mention.id, mention.project_id, mention.comment_id, mention.reply_id,
+  comment.file_path, comment.content AS comment_content, reply.content AS reply_content,
+  comment.resolved, mention.created_at, mention.read_at, mention.read_reason
+  FROM comment_mentions mention
+  JOIN comments comment ON comment.id = mention.comment_id
+  LEFT JOIN comment_replies reply ON reply.id = mention.reply_id`;
+export function listCommentMentions(db, projectId, userId, options = {}) {
+    const limit = Math.min(100, Math.max(1, options.limit ?? 50));
+    const unreadClause = options.unreadOnly ? "AND mention.read_at IS NULL" : "";
+    const fileClause = options.filePath ? "AND comment.file_path = ?" : "";
+    const parameters = options.filePath
+        ? [projectId, userId, options.filePath, limit]
+        : [projectId, userId, limit];
+    const rows = db.prepare(`${mentionSelect}
+    WHERE mention.project_id = ? AND mention.mentioned_user_id = ? ${unreadClause} ${fileClause}
+    ORDER BY mention.created_at DESC LIMIT ?`).all(...parameters);
+    return rows.map(mentionFromRow);
+}
+export function commentMentionForUser(db, mentionId, projectId, userId) {
+    const row = db.prepare(`${mentionSelect}
+    WHERE mention.id = ? AND mention.project_id = ? AND mention.mentioned_user_id = ?`)
+        .get(mentionId, projectId, userId);
+    return row ? mentionFromRow(row) : null;
+}
+/** Mark an item read after the UI has opened and located its target thread. */
+export function markCommentMentionRead(db, mentionId, userId, readAt, reason = "opened") {
+    return db.prepare(`UPDATE comment_mentions
+    SET read_at = ?, read_reason = ?
+    WHERE id = ? AND mentioned_user_id = ? AND read_at IS NULL`)
+        .run(readAt, reason, mentionId, userId).changes > 0;
+}
+/** Explicitly clear every unread notification in a project for one recipient. */
+export function markAllCommentMentionsRead(db, projectId, userId, readAt) {
+    return db.prepare(`UPDATE comment_mentions
+    SET read_at = ?, read_reason = 'manual'
+    WHERE project_id = ? AND mentioned_user_id = ? AND read_at IS NULL`)
+        .run(readAt, projectId, userId).changes;
+}
+/** Resolving a thread makes all existing unread mentions in it non-actionable. */
+export function markCommentMentionsResolved(db, commentId, resolvedAt) {
+    return db.prepare(`UPDATE comment_mentions
+    SET read_at = ?, read_reason = 'resolved'
+    WHERE comment_id = ? AND read_at IS NULL`)
+        .run(resolvedAt, commentId).changes;
+}

package/dist/server/config.js

@@ -22,8 +22,9 @@ export const CONFIG_DEFAULTS = {
     maxFileSizeMB: 50,
     pdfLoadingStrategy: "auto",
     pdfRangeThresholdMB: 5,
-    historyMaxVersions: 200,
+    historyMaxVersions: 0,
     historyMaxStorageMB: 128,
+    editHistoryMaxStorageMB: 32,
     git: "git",
     gitOperationTimeoutSeconds: 120,
     githubApiBaseUrl: "https://api.github.com"
@@ -35,8 +36,9 @@ const CONFIG_LIMITS = {
     maxCompileJobs: [1, 32],
     maxFileSizeMB: [1, 2_048],
     pdfRangeThresholdMB: [1, 2_048],
-    historyMaxVersions: [10, 5_000],
+    historyMaxVersions: [0, 50_000],
     historyMaxStorageMB: [16, 102_400],
+    editHistoryMaxStorageMB: [4, 102_400],
     gitOperationTimeoutSeconds: [1, 3_600]
 };
 export function loadConfig(configPathOverride) {
@@ -70,6 +72,7 @@ export function loadConfig(configPathOverride) {
     const pdfRangeThresholdMB = integerSetting("pdf.rangeThresholdMB", process.env.TEXLITE_PDF_RANGE_THRESHOLD_MB, fileConfig.pdf?.rangeThresholdMB, CONFIG_DEFAULTS.pdfRangeThresholdMB, CONFIG_LIMITS.pdfRangeThresholdMB);
     const historyMaxVersions = integerSetting("history.maxVersions", process.env.TEXLITE_HISTORY_MAX_VERSIONS, fileConfig.history?.maxVersions, CONFIG_DEFAULTS.historyMaxVersions, CONFIG_LIMITS.historyMaxVersions);
     const historyMaxStorageMB = integerSetting("history.maxStorageMB", process.env.TEXLITE_HISTORY_MAX_STORAGE_MB, fileConfig.history?.maxStorageMB, CONFIG_DEFAULTS.historyMaxStorageMB, CONFIG_LIMITS.historyMaxStorageMB);
+    const editHistoryMaxStorageMB = integerSetting("editHistory.maxStorageMB", process.env.TEXLITE_EDIT_HISTORY_MAX_STORAGE_MB, fileConfig.editHistory?.maxStorageMB, CONFIG_DEFAULTS.editHistoryMaxStorageMB, CONFIG_LIMITS.editHistoryMaxStorageMB);
     const gitOperationTimeoutSeconds = integerSetting("git.operationTimeoutSeconds", process.env.TEXLITE_GIT_TIMEOUT, fileConfig.git?.operationTimeoutSeconds, CONFIG_DEFAULTS.gitOperationTimeoutSeconds, CONFIG_LIMITS.gitOperationTimeoutSeconds);
     const config = {
         configPath,
@@ -94,6 +97,7 @@ export function loadConfig(configPathOverride) {
         pdfRangeThresholdBytes: pdfRangeThresholdMB * 1024 * 1024,
         historyMaxVersions,
         historyMaxStorageBytes: historyMaxStorageMB * 1024 * 1024,
+        editHistoryMaxStorageBytes: editHistoryMaxStorageMB * 1024 * 1024,
         git: stringSetting("git.binary", process.env.TEXLITE_GIT, fileConfig.git?.binary, CONFIG_DEFAULTS.git, { min: 1, max: 256 }),
         gitOperationTimeoutMs: gitOperationTimeoutSeconds * 1000,
         githubApiBaseUrl: stringSetting("git.githubApiBaseUrl", process.env.TEXLITE_GITHUB_API_URL, fileConfig.git?.githubApiBaseUrl, CONFIG_DEFAULTS.githubApiBaseUrl, { min: 1, max: 2_048 }).replace(/\/+$/, "")
@@ -132,6 +136,7 @@ export function validateConfig(config) {
     validateInteger("pdf.rangeThresholdMB", config.pdfRangeThresholdBytes / (1024 * 1024), CONFIG_LIMITS.pdfRangeThresholdMB);
     validateInteger("history.maxVersions", config.historyMaxVersions, CONFIG_LIMITS.historyMaxVersions);
     validateInteger("history.maxStorageMB", config.historyMaxStorageBytes / (1024 * 1024), CONFIG_LIMITS.historyMaxStorageMB);
+    validateInteger("editHistory.maxStorageMB", config.editHistoryMaxStorageBytes / (1024 * 1024), CONFIG_LIMITS.editHistoryMaxStorageMB);
     validateInteger("git.operationTimeoutSeconds", config.gitOperationTimeoutMs / 1000, CONFIG_LIMITS.gitOperationTimeoutSeconds);
 }
 function isEngine(value) {
@@ -176,6 +181,8 @@ function validateFileConfig(config) {
     const history = optionalSection(config.history, "history");
     optionalInteger(history?.maxVersions, "history.maxVersions", CONFIG_LIMITS.historyMaxVersions);
     optionalInteger(history?.maxStorageMB, "history.maxStorageMB", CONFIG_LIMITS.historyMaxStorageMB);
+    const editHistory = optionalSection(config.editHistory, "editHistory");
+    optionalInteger(editHistory?.maxStorageMB, "editHistory.maxStorageMB", CONFIG_LIMITS.editHistoryMaxStorageMB);
     const latex = optionalSection(config.latex, "latex");
     optionalString(latex?.latexmk, "latex.latexmk", { min: 1, max: 256 });
     if (latex && Object.prototype.hasOwnProperty.call(latex, "defaultEngine") && !isEngine(latex.defaultEngine)) {

package/dist/server/db.js

@@ -143,6 +143,27 @@ function migrate(db) {
     );
     CREATE INDEX IF NOT EXISTS comment_replies_comment_id ON comment_replies(comment_id, created_at);
 
+    -- Mentions are personal notification records, rather than a mutable
+    -- counter on comments or projects.  This makes unread state naturally
+    -- per user and lets resolving one thread clear its existing notifications.
+    CREATE TABLE IF NOT EXISTS comment_mentions (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      comment_id TEXT NOT NULL REFERENCES comments(id) ON DELETE CASCADE,
+      reply_id TEXT REFERENCES comment_replies(id) ON DELETE CASCADE,
+      mentioned_user_id TEXT NOT NULL REFERENCES users(id) ON DELETE CASCADE,
+      mentioned_by_user_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+      read_at TEXT,
+      read_reason TEXT CHECK (read_reason IN ('opened', 'resolved', 'manual')),
+      created_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS comment_mentions_receiver_unread
+      ON comment_mentions(mentioned_user_id, project_id, created_at DESC)
+      WHERE read_at IS NULL;
+    CREATE INDEX IF NOT EXISTS comment_mentions_comment_id ON comment_mentions(comment_id);
+    CREATE UNIQUE INDEX IF NOT EXISTS comment_mentions_source_recipient
+      ON comment_mentions(comment_id, IFNULL(reply_id, ''), mentioned_user_id);
+
     CREATE TABLE IF NOT EXISTS compile_runs (
       id TEXT PRIMARY KEY,
       project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
@@ -174,6 +195,37 @@ function migrate(db) {
       updated_at TEXT NOT NULL
     );
 
+    -- Recovery snapshots and collaborative edit records serve different
+    -- purposes. Snapshots are content-addressed restore points; these rows
+    -- retain the ordered, author-attributed text changes that led to the
+    -- current source, so a selected range can show who changed it.
+    CREATE TABLE IF NOT EXISTS project_edit_segments (
+      id TEXT PRIMARY KEY,
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      file_path TEXT NOT NULL,
+      author_id TEXT REFERENCES users(id) ON DELETE SET NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('edit', 'format')),
+      before_hash TEXT NOT NULL,
+      after_hash TEXT NOT NULL,
+      steps_json TEXT NOT NULL,
+      steps_bytes INTEGER NOT NULL DEFAULT 0,
+      created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL
+    );
+    CREATE INDEX IF NOT EXISTS project_edit_segments_project_file_updated
+      ON project_edit_segments(project_id, file_path, updated_at DESC);
+
+    -- Records the newest missing delta per file after retention drops an edit
+    -- segment. Selection history uses it to stop at a known boundary instead
+    -- of presenting an incomplete attribution as a full edit trail.
+    CREATE TABLE IF NOT EXISTS project_edit_history_boundaries (
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      file_path TEXT NOT NULL,
+      after_hash TEXT NOT NULL,
+      updated_at TEXT NOT NULL,
+      PRIMARY KEY (project_id, file_path)
+    );
+
     CREATE TABLE IF NOT EXISTS project_dictionary_words (
       project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
       word TEXT NOT NULL COLLATE NOCASE,
@@ -228,6 +280,13 @@ function migrate(db) {
       updated_at TEXT NOT NULL
     );
   `);
+    const editColumns = db.prepare("PRAGMA table_info(project_edit_segments)").all();
+    if (!editColumns.some((column) => column.name === "steps_bytes")) {
+        db.transaction(() => {
+            db.exec("ALTER TABLE project_edit_segments ADD COLUMN steps_bytes INTEGER NOT NULL DEFAULT 0");
+            db.exec("UPDATE project_edit_segments SET steps_bytes = LENGTH(CAST(steps_json AS BLOB))");
+        })();
+    }
     const projectColumns = db.prepare("PRAGMA table_info(projects)").all();
     if (!projectColumns.some((column) => column.name === "latexmkrc")) {
         db.exec("ALTER TABLE projects ADD COLUMN latexmkrc TEXT");