projview 1.0.0 → 1.2.0

package/src/store.js

@@ -5,6 +5,8 @@
  *   entries  - indexed files { path, name, ext, mtime, content }
  *   comments - notes on a file or a portion of it (see anchor model below)
  *   events   - usage signals { ts, type, file?, query?, count? }
+ *   versions - earlier text of a file { id, file, mtime, replacedAt, content },
+ *              newest VERSION_LIMIT kept per file (older ones are pruned)
  *
  * Backends:
  *   memory    - no disk persistence (ephemeral default; lives only this session)
@@ -69,6 +71,17 @@ const newEvent = (e) => ({
   count: e.count ?? null
 });
 
+// How many earlier versions of each file are kept.
+export const VERSION_LIMIT = 5;
+const newVersion = (v) => ({
+  id: randomUUID(),
+  file: v.file,
+  mtime: v.mtime ?? null,          // when this text was written (its file mtime)
+  replacedAt: v.replacedAt || Date.now(),
+  content: v.content
+});
+const versionMeta = ({ id, file, mtime, replacedAt, content }) => ({ id, file, mtime, replacedAt, size: Buffer.byteLength(content) });
+
 // Aggregate raw events into something a human / agent can read at a glance.
 function summarizeEvents(events) {
   const byType = {};
@@ -137,12 +150,30 @@ function fileFor(root, persist, ext) {
 
 // Holds comments + events in memory; calls flush() after each mutation so a
 // disk-backed wrapper (superlite) can persist. memory passes a no-op flush.
-function inMemoryDocs(flush = async () => {}) {
+// Versions get their own flush: they're large, and shouldn't be rewritten on
+// every page view or search event.
+function inMemoryDocs(flush = async () => {}, flushVersions = flush) {
   const comments = new Map();   // id -> comment
   const events = [];            // append-only (stable ref - never reassigned)
+  const versions = [];          // oldest first (stable ref - pruned in place)
   return {
     comments,
     events,
+    versions,
+    async addVersion(v) {
+      const version = newVersion(v);
+      versions.push(version);
+      const mine = versions.filter((x) => x.file === version.file);
+      for (const old of mine.slice(0, Math.max(0, mine.length - VERSION_LIMIT))) versions.splice(versions.indexOf(old), 1);
+      await flushVersions();
+      return versionMeta(version);
+    },
+    async listVersions(file) {
+      return versions.filter((x) => x.file === file).reverse().map(versionMeta);
+    },
+    async getVersion(id) {
+      return versions.find((x) => x.id === id) || null;
+    },
     async addComment(c) {
       const comment = newComment(c);
       comments.set(comment.id, comment);
@@ -189,6 +220,9 @@ function memoryStore() {
     deleteComment: docs.deleteComment,
     recordEvent: docs.recordEvent,
     usageStats: docs.usageStats,
+    addVersion: docs.addVersion,
+    listVersions: docs.listVersions,
+    getVersion: docs.getVersion,
     async close() {},
     describe() { return 'in-memory (ephemeral - nothing persisted)'; }
   };
@@ -196,6 +230,7 @@ function memoryStore() {
 
 function superliteStore(root, persist) {
   const file = fileFor(root, persist, 'json');
+  const versionsFile = file.replace(/\.json$/, '.versions.json');   // big, so written only when versions change
   const entries = new Map();   // path -> entry
   let loaded = false;
   const flush = () => fsp.writeFile(file, JSON.stringify({
@@ -204,7 +239,8 @@ function superliteStore(root, persist) {
     comments: [...docs.comments.values()],
     events: docs.events
   }));
-  const docs = inMemoryDocs(() => (loaded ? flush() : Promise.resolve()));
+  const flushVersions = () => fsp.writeFile(versionsFile, JSON.stringify(docs.versions));
+  const docs = inMemoryDocs(() => (loaded ? flush() : Promise.resolve()), () => (loaded ? flushVersions() : Promise.resolve()));
   const ensure = async () => {
     if (loaded) return;
     try {
@@ -213,11 +249,15 @@ function superliteStore(root, persist) {
       for (const c of d.comments || []) docs.comments.set(c.id, c);
       for (const ev of d.events || []) docs.events.push(ev);
     } catch { /* fresh */ }
+    try {
+      for (const v of JSON.parse(await fsp.readFile(versionsFile, 'utf8'))) docs.versions.push(v);
+    } catch { /* no history yet */ }
     loaded = true;
   };
   return {
     kind: 'superlite',
     file,
+    versionsFile,
     async load() { await ensure(); return entries.size ? { entries: [...entries.values()] } : null; },
     async save(es) { await ensure(); entries.clear(); for (const e of es) entries.set(e.path, e); await flush(); },
     async update(entry) { await ensure(); entries.set(entry.path, entry); await flush(); },
@@ -228,8 +268,13 @@ function superliteStore(root, persist) {
     async deleteComment(id) { await ensure(); return docs.deleteComment(id); },
     async recordEvent(e) { await ensure(); return docs.recordEvent(e); },
     async usageStats() { await ensure(); return docs.usageStats(); },
+    async addVersion(v) { await ensure(); return docs.addVersion(v); },
+    async listVersions(f) { await ensure(); return docs.listVersions(f); },
+    async getVersion(id) { await ensure(); return docs.getVersion(id); },
     async close({ keep } = {}) {
-      if (!persist && !keep) { try { await fsp.unlink(file); } catch { /* gone */ } }
+      if (!persist && !keep) {
+        for (const f of [file, versionsFile]) { try { await fsp.unlink(f); } catch { /* gone */ } }
+      }
     },
     describe() { return `superlite/json (${persist ? 'persisted' : 'ephemeral'}) ${file}`; }
   };
@@ -249,6 +294,7 @@ function sqliteAt(file, { cleanup }) {
     db.exec('CREATE TABLE IF NOT EXISTS files (path TEXT PRIMARY KEY, name TEXT, ext TEXT, mtime REAL, content TEXT)');
     db.exec('CREATE TABLE IF NOT EXISTS comments (id TEXT PRIMARY KEY, file TEXT, anchor TEXT, body TEXT, author TEXT, createdAt REAL, resolved INTEGER)');
     db.exec('CREATE TABLE IF NOT EXISTS events (id TEXT PRIMARY KEY, ts REAL, type TEXT, file TEXT, query TEXT, count INTEGER)');
+    db.exec('CREATE TABLE IF NOT EXISTS versions (id TEXT PRIMARY KEY, file TEXT, mtime REAL, replacedAt REAL, content TEXT)');
     return db;
   };
   const writeComment = (d, c) => d
@@ -314,6 +360,23 @@ function sqliteAt(file, { cleanup }) {
       const d = await open();
       return summarizeEvents(d.prepare('SELECT type, file, query FROM events').all());
     },
+    async addVersion(v) {
+      const d = await open();
+      const version = newVersion(v);
+      d.prepare('INSERT INTO versions (id, file, mtime, replacedAt, content) VALUES (?, ?, ?, ?, ?)')
+        .run(version.id, version.file, version.mtime, version.replacedAt, version.content);
+      d.prepare('DELETE FROM versions WHERE file = ? AND id NOT IN (SELECT id FROM versions WHERE file = ? ORDER BY replacedAt DESC LIMIT ?)')
+        .run(version.file, version.file, VERSION_LIMIT);
+      return versionMeta(version);
+    },
+    async listVersions(file) {
+      const d = await open();
+      return d.prepare('SELECT * FROM versions WHERE file = ? ORDER BY replacedAt DESC').all(file).map(versionMeta);
+    },
+    async getVersion(id) {
+      const d = await open();
+      return d.prepare('SELECT * FROM versions WHERE id = ?').get(id) || null;
+    },
     async close({ keep } = {}) {
       if (db) { db.close(); db = null; }
       if (cleanup && !keep) { try { await fsp.unlink(file); } catch { /* gone */ } }
@@ -353,8 +416,11 @@ function postgresStore(url) {
     await client.query('CREATE TABLE IF NOT EXISTS projview_files (path TEXT PRIMARY KEY, name TEXT, ext TEXT, mtime DOUBLE PRECISION, content TEXT)');
     await client.query('CREATE TABLE IF NOT EXISTS projview_comments (id TEXT PRIMARY KEY, file TEXT, anchor TEXT, body TEXT, author TEXT, createdat DOUBLE PRECISION, resolved BOOLEAN)');
     await client.query('CREATE TABLE IF NOT EXISTS projview_events (id TEXT PRIMARY KEY, ts DOUBLE PRECISION, type TEXT, file TEXT, query TEXT, count INTEGER)');
+    await client.query('CREATE TABLE IF NOT EXISTS projview_versions (id TEXT PRIMARY KEY, file TEXT, mtime DOUBLE PRECISION, replacedat DOUBLE PRECISION, content TEXT)');
     return client;
   };
+  // postgres folds unquoted identifiers to lower case
+  const toVersion = (r) => ({ id: r.id, file: r.file, mtime: r.mtime == null ? null : Number(r.mtime), replacedAt: Number(r.replacedat), content: r.content });
   const writeComment = (c) => client.query(
     'INSERT INTO projview_comments (id, file, anchor, body, author, createdat, resolved) VALUES ($1, $2, $3, $4, $5, $6, $7)' +
       ' ON CONFLICT (id) DO UPDATE SET file = $2, anchor = $3, body = $4, author = $5, createdat = $6, resolved = $7',
@@ -428,6 +494,25 @@ function postgresStore(url) {
       const { rows } = await c.query('SELECT type, file, query FROM projview_events');
       return summarizeEvents(rows);
     },
+    async addVersion(v) {
+      const c = await open();
+      const version = newVersion(v);
+      await c.query('INSERT INTO projview_versions (id, file, mtime, replacedat, content) VALUES ($1, $2, $3, $4, $5)',
+        [version.id, version.file, version.mtime, version.replacedAt, version.content]);
+      await c.query('DELETE FROM projview_versions WHERE file = $1 AND id NOT IN (SELECT id FROM projview_versions WHERE file = $1 ORDER BY replacedat DESC LIMIT $2)',
+        [version.file, VERSION_LIMIT]);
+      return versionMeta(version);
+    },
+    async listVersions(file) {
+      const c = await open();
+      const { rows } = await c.query('SELECT * FROM projview_versions WHERE file = $1 ORDER BY replacedat DESC', [file]);
+      return rows.map((r) => versionMeta(toVersion(r)));
+    },
+    async getVersion(id) {
+      const c = await open();
+      const { rows } = await c.query('SELECT * FROM projview_versions WHERE id = $1', [id]);
+      return rows.length ? toVersion(rows[0]) : null;
+    },
     async close() { if (client) { await client.end(); client = null; } },   // never drop the user's tables
     describe() { return `custom/postgres ${redact(url)}`; }
   };

package/src/walk.js

@@ -7,14 +7,24 @@ const IGNORED_DIRS = new Set([
   '.cache', '.turbo', 'vendor', '.venv', '__pycache__'
 ]);
 
-export const PREVIEWABLE_EXTS = new Set(['.md', '.mmd']);
+export const PREVIEWABLE_EXTS = new Set(['.md', '.mmd', '.json', '.yml', '.yaml']);
+
+// Previewable by extension but machine-generated noise - huge, never read.
+const IGNORED_FILES = new Set(['package-lock.json', 'pnpm-lock.yaml']);
 
 // True if a path segment should stop the walk (ignored name or any dot-dir).
 export function isIgnoredDir(name) {
   return IGNORED_DIRS.has(name) || name.startsWith('.');
 }
 
+// True if any directory in a root-relative path is one the walk skips - so a
+// file hidden from the tree can't be fetched by typing its path either.
+export function isHiddenPath(relPath) {
+  return relPath.split(/[\\/]/).slice(0, -1).some(isIgnoredDir);
+}
+
 export function isPreviewable(filePath) {
+  if (IGNORED_FILES.has(path.basename(filePath).toLowerCase())) return false;
   return PREVIEWABLE_EXTS.has(path.extname(filePath).toLowerCase());
 }