folderview 0.1.0 → 0.2.1

package/dist/git.js

@@ -159,8 +159,8 @@ export class Git {
             execFile('git', ['show', `${rev}:${this.repoPath(rel)}`], { cwd: this.top, encoding: 'buffer', maxBuffer: 256 * 1024 * 1024, windowsHide: true }, (err, stdout) => err ? reject(err) : resolve(stdout));
         });
     }
-    async log(rel, limit = 30) {
-        const out = await this.git(['log', '--follow', `-n${limit}`, '--format=%h%x1f%an%x1f%at%x1f%s%x1e', '--', this.repoPath(rel)]).catch(() => '');
+    async log(rel, limit = 30, skip = 0) {
+        const out = await this.git(['log', '--follow', `-n${limit}`, `--skip=${skip}`, '--format=%h%x1f%an%x1f%at%x1f%s%x1e', '--', this.repoPath(rel)]).catch(() => '');
         return out
             .split('\x1e')
             .map((r) => r.trim())
@@ -174,6 +174,125 @@ export class Git {
     commitDiff(rel, hash) {
         return this.git(['show', '--no-color', '--format=%H%n%an <%ae>%n%ad%n%n%B', '-M', hash, '--', this.repoPath(rel)]);
     }
+    /**
+     * The repository's commits (those touching the served folder), newest first, each marked pushed or local, plus
+     * the upstream's commits not pulled yet (on the first page).
+     */
+    async history(skip = 0, limit = 50, q = '') {
+        const scope = this.prefix ? ['--', this.prefix] : [];
+        const none = () => '';
+        // a search: words in the message (any case), or the start of a hash
+        const find = q ? ['-i', '-F', `--grep=${q}`] : [];
+        const first = !skip && !q;
+        // every question at once (each git call costs a process start, slow on Windows); the ones that can't apply
+        // (no upstream, no remote, no commits yet) just fail to ''
+        const [remoteList, up, out, hashOut, inRaw, inCount, localRaw, localScoped] = await Promise.all([
+            this.git(['remote']).catch(none),
+            this.git(['rev-parse', '--abbrev-ref', '--symbolic-full-name', '@{u}']).catch(none),
+            this.git(['log', `-n${limit + 1}`, `--skip=${skip}`, `--format=${LOG_FORMAT}`, ...find, 'HEAD', ...scope]).catch(none),
+            /^[0-9a-f]{4,40}$/i.test(q) && !skip ? this.git(['log', '-n1', `--format=${LOG_FORMAT}`, q, '--']).catch(none) : '',
+            first ? this.git(['log', '-n50', `--format=${LOG_FORMAT}`, 'HEAD..@{u}', ...scope]).catch(none) : '',
+            first ? this.git(['rev-list', '--count', 'HEAD..@{u}', ...scope]).catch(none) : '',
+            // the commits only here (up to a limit, so a never-pushed giant history stays quick)
+            this.git(['rev-list', `--max-count=${LOCAL_CAP + 1}`, 'HEAD', '--not', '--remotes']).catch(none),
+            first && this.prefix ? this.git(['rev-list', '--count', `--max-count=${LOCAL_CAP + 1}`, 'HEAD', '--not', '--remotes', ...scope]).catch(none) : '',
+        ]);
+        const remotes = remoteList.trim() !== '';
+        const upstream = up.trim() || undefined;
+        const h = { commits: [], incoming: [], incomingTotal: 0, more: false, remotes, ...(upstream ? { upstream } : {}) };
+        let all = parseLog(out);
+        h.more = all.length > limit;
+        all = all.slice(0, limit);
+        const hit = parseLog(hashOut)[0];
+        if (hit && !all.some((c) => c.full === hit.full))
+            all.unshift(hit);
+        h.commits = all.map((c) => ({ ...c, state: remotes ? 'pushed' : 'unknown' }));
+        const localList = localRaw.split('\n').filter(Boolean);
+        if (remotes && all.length) {
+            let local = new Set(localList);
+            if (localList.length > LOCAL_CAP) {
+                // more unpushed commits than the list holds: ask again for just this page's stretch of time (the unpushed
+                // ones no older than its oldest commit, a day's slack for clock skew)
+                const oldest = Math.floor(Math.min(...all.map((c) => c.time)) / 1000 - 86400);
+                local = new Set((await this.git(['rev-list', `--since=${oldest}`, 'HEAD', '--not', '--remotes']).catch(none)).split('\n').filter(Boolean));
+            }
+            for (const c of h.commits)
+                if (local.has(c.full))
+                    c.state = 'local';
+        }
+        if (upstream) {
+            h.incoming = parseLog(inRaw).map((c) => ({ ...c, state: 'incoming' }));
+            h.incomingTotal = Number(inCount.trim()) || h.incoming.length;
+        }
+        if (remotes && first) {
+            const n = this.prefix ? Number(localScoped.trim()) || 0 : localList.length;
+            h.localTotal = n > LOCAL_CAP ? `${LOCAL_CAP}+` : String(n);
+        }
+        return h;
+    }
+    /** what a commit was, and which files (in the served folder) it changed, against its first parent */
+    async commitInfo(rev) {
+        const raw = await this.git(['show', '-s', '--format=%H%x1f%h%x1f%an%x1f%ae%x1f%at%x1f%P%x1f%s%x1f%b', rev]);
+        const [full = '', hash = '', author = '', email = '', time = '0', parents = '', subject = '', ...rest] = raw.replace(/\n$/, '').split('\x1f');
+        const base = await this.parentOf(full);
+        const scope = this.prefix ? ['--', this.prefix] : [];
+        const [names, nums] = await Promise.all([
+            this.git(['diff', '--name-status', '-z', '-M', base, full, ...scope]),
+            this.git(['diff', '--numstat', '-z', '-M', base, full, ...scope]),
+        ]);
+        const files = [];
+        const recs = names.split('\0');
+        for (let i = 0; i < recs.length; i++) {
+            const s = recs[i];
+            if (!s)
+                continue;
+            let from;
+            let file = recs[++i] ?? '';
+            if (s[0] === 'R' || s[0] === 'C') {
+                from = file;
+                file = recs[++i] ?? '';
+            }
+            const rel = this.fromRepo(file);
+            if (rel === undefined)
+                continue;
+            const state = s[0] === 'A' || s[0] === 'C' ? 'added' : s[0] === 'D' ? 'deleted' : s[0] === 'R' ? 'renamed' : 'modified';
+            const f = { path: rel, state };
+            if (from)
+                f.from = this.fromRepo(from) ?? from;
+            files.push(f);
+        }
+        const byPath = new Map(files.map((f) => [f.path, f]));
+        const nr = nums.split('\0');
+        for (let i = 0; i < nr.length; i++) {
+            const m = /^(\d+|-)\t(\d+|-)\t(.*)$/.exec(nr[i] ?? '');
+            if (!m)
+                continue;
+            let file = m[3] ?? '';
+            if (!file) {
+                i++;
+                file = nr[++i] ?? '';
+            }
+            const f = byPath.get(this.fromRepo(file) ?? '');
+            if (f && m[1] !== '-') {
+                f.add = Number(m[1]);
+                f.del = Number(m[2]);
+            }
+        }
+        return {
+            commit: { full, hash, author, email, time: Number(time) * 1000, parents: parents.split(' ').filter(Boolean), subject, body: rest.join('\x1f').trim() },
+            files,
+        };
+    }
+    /** one file's diff in a commit, against the commit's first parent (a rename needs its old path too) */
+    async commitFileDiff(rev, rel, fromRel) {
+        const full = (await this.git(['rev-parse', '--verify', rev + '^{commit}'])).trim();
+        const base = await this.parentOf(full);
+        const paths = [this.repoPath(rel), ...(fromRel ? [this.repoPath(fromRel)] : [])];
+        return this.git(['diff', '--no-color', '-M', base, full, '--', ...paths]);
+    }
+    async parentOf(full) {
+        return (await this.git(['rev-parse', '--verify', '-q', full + '^1']).catch(() => '')).trim() || EMPTY_TREE;
+    }
     async userName() {
         return (await this.git(['config', 'user.name']).catch(() => '')).trim();
     }
@@ -218,6 +337,20 @@ function stateOf(x, y) {
         return 'added';
     return 'modified';
 }
+const LOCAL_CAP = 1000;
+const LOG_FORMAT = '%H%x1f%h%x1f%an%x1f%at%x1f%P%x1f%s%x1e';
+/** git's empty tree: what a first commit is compared with */
+const EMPTY_TREE = '4b825dc642cb6eb9a060e54bf8d69288fbee4904';
+function parseLog(out) {
+    return out
+        .split('\x1e')
+        .map((r) => r.trim())
+        .filter(Boolean)
+        .map((r) => {
+        const [full = '', hash = '', author = '', time = '0', parents = '', subject = ''] = r.split('\x1f');
+        return { full, hash, author, time: Number(time) * 1000, parents: parents.split(' ').filter(Boolean), subject };
+    });
+}
 const nullDevice = () => (process.platform === 'win32' ? 'NUL' : '/dev/null');
 function run(cwd, args, ok = [0]) {
     return new Promise((resolve, reject) => {

package/dist/review.js

@@ -107,6 +107,15 @@ export class Review {
             if (quote !== undefined)
                 c.quote = quote;
         }
+        if (input.area)
+            c.area = input.area;
+        if (input.strokes?.length)
+            c.strokes = input.strokes;
+        if (input.snapshot) {
+            fs.mkdirSync(path.join(this.dir, 'images'), { recursive: true });
+            c.image = `images/${c.id}.png`;
+            fs.writeFileSync(path.join(this.dir, c.image), input.snapshot);
+        }
         if (input.commit)
             c.commit = input.commit;
         this.comments.push(c);
@@ -135,19 +144,35 @@ export class Review {
         return c;
     }
     remove(id) {
-        const n = this.comments.length;
-        this.comments = this.comments.filter((c) => c.id !== id);
-        if (this.comments.length === n)
+        const gone = this.comments.find((c) => c.id === id);
+        if (!gone)
             return false;
+        this.comments = this.comments.filter((c) => c.id !== id);
+        this.dropImage(gone);
         this.save();
         return true;
     }
     clearResolved() {
         const n = this.comments.length;
+        for (const c of this.comments)
+            if (c.status === 'resolved')
+                this.dropImage(c);
         this.comments = this.comments.filter((c) => c.status !== 'resolved');
         this.save();
         return n - this.comments.length;
     }
+    /** the marked-up picture of an image comment, as a path inside the review folder (or undefined) */
+    imagePath(id) {
+        const c = this.comments.find((x) => x.id === id);
+        if (!c?.image || !/^images\/[0-9a-f]+\.png$/.test(c.image))
+            return undefined;
+        const abs = path.join(this.dir, c.image);
+        return fs.existsSync(abs) ? abs : undefined;
+    }
+    dropImage(c) {
+        if (c.image && /^images\/[0-9a-f]+\.png$/.test(c.image))
+            fs.rmSync(path.join(this.dir, c.image), { force: true });
+    }
     quote(rel, from, to) {
         try {
             const abs = path.join(this.root, rel);
@@ -202,7 +227,7 @@ export function toMarkdown(comments, jsonRel, { openOnly = false } = {}) {
         '',
         '## How to work through this (for an agent)',
         '',
-        '- Each comment is on a file, or on lines of it (`path:line`). Paths are relative to the folder folderview serves.',
+        '- Each comment is on a file, on lines of it (`path:line`), or on an area of an image (marked by hand; `images/<id>.png` beside this file shows the marks). Paths are relative to the folder folderview serves.',
         '- The quoted code is what the lines said when the comment was left; the file may have moved on since, so find the code, not just the line number.',
         `- When a comment is dealt with, set its \`"status"\` to \`"resolved"\` in \`${jsonRel}\` and, if there is something to say, add a reply:`,
         '  `"replies": [{ "id": "a1", "author": "agent", "body": "Done: …", "at": "<ISO time>" }]`. The reviewer sees it live.',
@@ -219,10 +244,14 @@ export function toMarkdown(comments, jsonRel, { openOnly = false } = {}) {
                 file = c.path;
                 out.push(`### ${file || '(the whole folder)'}`, '');
             }
-            const where = c.line ? `${c.path}:${c.line}${c.endLine ? '-' + c.endLine : ''}` : `${c.path || '.'} (whole file)`;
+            const where = c.line ? `${c.path}:${c.line}${c.endLine ? '-' + c.endLine : ''}` : c.area ? `${c.path} (marked area)` : `${c.path || '.'} (whole file)`;
             out.push(`#### \`${where}\` — ${c.author}${c.commit ? ` @ ${c.commit}` : ''} · id \`${c.id}\``, '');
             if (c.quote)
                 out.push('```' + langOf(c.path), c.quote, '```', '');
+            if (c.area)
+                out.push(`Marked area: x ${c.area.x}, y ${c.area.y}, ${c.area.w} × ${c.area.h} px of the image.` + (c.image ? ` The marks are drawn on a copy: ${c.image} (beside this file).` : ''), '');
+            if (c.image)
+                out.push(`![The marked area](${c.image})`, '');
             out.push(c.body, '');
             for (const r of c.replies ?? [])
                 out.push(`> **${r.author}**: ${r.body.replace(/\n/g, '\n> ')}`, '');

package/dist/server.js

@@ -219,7 +219,30 @@ export async function start(opts) {
                     return void res.end(buf);
                 }
                 case '/api/git/log':
-                    return json(res, 200, { commits: await git.log(rel) });
+                    {
+                        // a page of the file's commits, and whether there are more
+                        const all = await git.log(rel, 31, Math.max(0, Number(q('skip')) || 0));
+                        return json(res, 200, { commits: all.slice(0, 30), more: all.length > 30 });
+                    }
+                case '/api/git/history':
+                    return json(res, 200, await git.history(Math.max(0, Number(q('skip')) || 0), 50, q('q').trim().slice(0, 200)));
+                case '/api/git/commit-info': {
+                    const h = q('h');
+                    if (!isRev(h))
+                        return json(res, 400, { error: 'bad revision' });
+                    const info = await git.commitInfo(h);
+                    info.files = info.files.filter((f) => visible(f.path) && (!reviewPrefix || !f.path.startsWith(reviewPrefix)));
+                    return json(res, 200, info);
+                }
+                case '/api/git/commit-diff': {
+                    const h = q('h');
+                    const from = q('from');
+                    if (!isRev(h))
+                        return json(res, 400, { error: 'bad revision' });
+                    if (from && inside(scope, from) === undefined)
+                        return json(res, 404, { error: 'not found' });
+                    return text(res, await git.commitFileDiff(h, rel, from || undefined));
+                }
                 case '/api/git/commit': {
                     const h = q('h');
                     if (!isRev(h))
@@ -234,8 +257,16 @@ export async function start(opts) {
         }
         if (p === '/api/comments' && method === 'GET')
             return json(res, 200, { comments: review.all() });
+        const img = /^\/api\/comments\/([0-9a-f]+)\/image\.png$/.exec(p);
+        if (img) {
+            const abs = review.imagePath(img[1] ?? '');
+            if (!abs)
+                return json(res, 404, { error: 'not found' });
+            res.writeHead(200, { 'content-type': 'image/png', 'cache-control': 'no-store', 'x-content-type-options': 'nosniff' });
+            return void fs.createReadStream(abs).pipe(res);
+        }
         if (p === '/api/comments' && method === 'POST') {
-            const b = await body(req);
+            const b = await body(req, 16_000_000);
             const rel = str(b['path']);
             if (inside(scope, rel) === undefined)
                 return json(res, 400, { error: 'No such file' });
@@ -248,6 +279,7 @@ export async function start(opts) {
                 author: str(b['author']) || author,
                 ...(line ? { line } : {}),
                 ...(endLine ? { endLine } : {}),
+                ...imageMarks(b),
                 ...(git ? { commit: (await gitStatus().catch(() => undefined))?.head ?? '' } : {}),
             });
             return json(res, 201, c);
@@ -390,7 +422,37 @@ function json(res, code, data) {
 function text(res, body, type = 'text/plain; charset=utf-8') {
     res.writeHead(200, { 'content-type': type, 'cache-control': 'no-store' }).end(body);
 }
-async function body(req) {
+/** an image comment's marks: the area, the strokes, and the marked-up picture (a PNG data URL) */
+function imageMarks(b) {
+    const out = {};
+    const a = b['area'];
+    if (a && typeof a === 'object' && !Array.isArray(a)) {
+        const r = Object.fromEntries(Object.entries(a));
+        const n = (k) => (typeof r[k] === 'number' && Number.isFinite(r[k]) && Number(r[k]) >= 0 ? Math.round(Number(r[k])) : undefined);
+        const [x, y, w, h] = [n('x'), n('y'), n('w'), n('h')];
+        if (x !== undefined && y !== undefined && w && h)
+            out.area = { x, y, w, h };
+    }
+    const s = b['strokes'];
+    if (Array.isArray(s)) {
+        let budget = 20_000;
+        const strokes = s
+            .filter((st) => Array.isArray(st))
+            .map((st) => st.filter((v) => typeof v === 'number' && v >= 0 && v <= 1).map((v) => Math.round(v * 10000) / 10000))
+            .filter((st) => st.length >= 2 && st.length % 2 === 0 && (budget -= st.length) >= 0);
+        if (strokes.length)
+            out.strokes = strokes;
+    }
+    const snap = typeof b['snapshot'] === 'string' ? /^data:image\/png;base64,([A-Za-z0-9+/=]+)$/.exec(b['snapshot']) : null;
+    if (snap && out.strokes) {
+        const buf = Buffer.from(snap[1] ?? '', 'base64');
+        // a PNG, and nothing else
+        if (buf.subarray(0, 8).equals(Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a])))
+            out.snapshot = buf;
+    }
+    return out;
+}
+async function body(req, max = 1_000_000) {
     if (!String(req.headers['content-type'] ?? '').includes('application/json'))
         throw new Error('Send JSON');
     const chunks = [];
@@ -398,7 +460,7 @@ async function body(req) {
     for await (const c of req) {
         const b = Buffer.isBuffer(c) ? c : Buffer.from(String(c));
         size += b.length;
-        if (size > 1_000_000)
+        if (size > max)
             throw new Error('Too large');
         chunks.push(b);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "folderview",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Browse, search and review any folder in your browser: highlighted code, rendered markdown with mermaid and math, git status and diffs, full-text search, downloads, and review comments saved where an LLM can read them.",
   "type": "module",
   "bin": {