hitloop 0.0.0-stage → 0.1.1

package/dist/client/index.html

@@ -0,0 +1,59 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover, interactive-widget=resizes-content" />
+    <meta name="theme-color" content="#f8f8fb" media="(prefers-color-scheme: light)" />
+    <meta name="theme-color" content="#16171c" media="(prefers-color-scheme: dark)" />
+    <meta name="referrer" content="no-referrer" />
+    <meta name="apple-mobile-web-app-capable" content="yes" />
+    <meta name="apple-mobile-web-app-title" content="hitl" />
+    <title>hitl — Human In The Loop</title>
+    <link rel="icon" href="assets/icon.svg" />
+    <link rel="apple-touch-icon" href="assets/icon.svg" />
+    <link rel="manifest" href="manifest.webmanifest" />
+    <link rel="stylesheet" href="assets/app.css" />
+    <script>
+      // the saved theme before anything draws, so a dark page never flashes white
+      try {
+        const t = localStorage.getItem('hitl:theme');
+        if (t === 'light' || t === 'dark') document.documentElement.dataset.theme = t;
+      } catch {}
+    </script>
+  </head>
+  <body data-view="">
+    <div class="shell">
+      <header class="bar" id="bar">
+        <a class="brand" id="home" href="#/" title="Everything waiting on you (Human In The Loop)">
+          <span class="logo"><svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.4" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="7.5" r="3.2" /><path d="M5.5 20a6.5 6.5 0 0 1 13 0" /><path d="M19.5 4.5a9 9 0 0 1 0 6M4.5 4.5a9 9 0 0 0 0 6" /></svg></span><b>hitl</b><span class="count" id="inbox-count" hidden>0</span>
+        </a>
+        <button class="proj-pick" id="proj" type="button" hidden><span class="proj-mark" id="proj-mark"></span><span class="proj-label" id="proj-name"></span><span id="proj-caret"></span></button>
+        <nav class="nav-tabs" id="tabs" aria-label="Sections">
+          <a class="nav-tab" data-tab="inbox" id="tab-inbox"><span class="tab-ic"></span><span class="tab-label">Inbox</span><span class="count" id="proj-count" hidden>0</span></a>
+          <a class="nav-tab" data-tab="files" id="tab-files"><span class="tab-ic"></span><span class="tab-label">Files</span></a>
+          <a class="nav-tab" data-tab="changes" id="changes-btn"><span class="tab-ic"></span><span class="tab-label">Changes</span><span class="count" id="changes-count" hidden>0</span></a>
+          <a class="nav-tab" data-tab="notes" id="review-btn"><span class="tab-ic"></span><span class="tab-label">Notes</span><span class="count warn" id="review-count" hidden>0</span></a>
+          <a class="nav-tab" data-tab="decisions" id="tab-decisions"><span class="tab-ic"></span><span class="tab-label">Decisions</span></a>
+        </nav>
+        <span id="branch"></span>
+        <form class="search" id="search-form" role="search">
+          <span id="search-icon"></span>
+          <input id="q" type="search" placeholder="Search in files" aria-label="Search in files" autocomplete="off" spellcheck="false" enterkeyhint="search" />
+          <button type="button" class="chip" id="scope">everywhere</button>
+        </form>
+        <nav class="bar-acts">
+          <button class="icon-btn" id="qo-btn" title="Go to a file (Ctrl+P)" aria-label="Go to a file"></button>
+          <button class="icon-btn" id="settings-btn" title="Settings" aria-label="Settings"></button>
+          <span class="live" id="live" title="Live: updates as things change"></span>
+        </nav>
+      </header>
+      <div class="app page" id="app">
+        <aside class="tree" aria-label="Folders"><ul class="roots" id="tree"></ul></aside>
+        <div class="splitter-wrap"><div class="splitter" id="splitter" title="Drag to resize"></div></div>
+        <section class="main" id="main" aria-live="polite"><div class="skeleton" style="height: 120px; margin: 24px"></div></section>
+        <section class="file" id="file" aria-label="File" hidden></section>
+      </div>
+    </div>
+    <script type="module" src="assets/main.js"></script>
+  </body>
+</html>

package/dist/diff.js

@@ -0,0 +1,119 @@
+// A line diff (Myers' O(ND) algorithm) written as a unified diff: for "changed since shown" (a file against its
+// snapshot) and for before/after text in a review, where there is no git to ask.
+/** the edit script from a to b, as kept / removed / added lines */
+export function diffLines(a, b, maxD = 4000) {
+    // trim the common start and end: most edits are small, and this keeps the search tiny
+    let start = 0;
+    while (start < a.length && start < b.length && a[start] === b[start])
+        start++;
+    let endA = a.length, endB = b.length;
+    while (endA > start && endB > start && a[endA - 1] === b[endB - 1]) {
+        endA--;
+        endB--;
+    }
+    const A = a.slice(start, endA), B = b.slice(start, endB);
+    const head = a.slice(0, start).map((line) => ({ t: ' ', line }));
+    const tail = a.slice(endA).map((line) => ({ t: ' ', line }));
+    const N = A.length, M = B.length;
+    const max = N + M;
+    if (!N || !M)
+        return [...head, ...A.map((line) => ({ t: '-', line })), ...B.map((line) => ({ t: '+', line })), ...tail];
+    const off = max;
+    const v = new Int32Array(2 * max + 2);
+    const trace = [];
+    let found = -1;
+    for (let d = 0; d <= Math.min(max, maxD); d++) {
+        trace.push(v.slice());
+        for (let k = -d; k <= d; k += 2) {
+            let x = k === -d || (k !== d && (v[off + k - 1] ?? 0) < (v[off + k + 1] ?? 0)) ? (v[off + k + 1] ?? 0) : (v[off + k - 1] ?? 0) + 1;
+            let y = x - k;
+            while (x < N && y < M && A[x] === B[y]) {
+                x++;
+                y++;
+            }
+            v[off + k] = x;
+            if (x >= N && y >= M) {
+                found = d;
+                break;
+            }
+        }
+        if (found >= 0)
+            break;
+    }
+    if (found < 0) {
+        // too different to be worth the search: everything out, everything in
+        return [...head, ...A.map((line) => ({ t: '-', line })), ...B.map((line) => ({ t: '+', line })), ...tail];
+    }
+    const ops = [];
+    let x = N, y = M;
+    for (let d = found; d > 0; d--) {
+        const vv = trace[d];
+        const k = x - y;
+        const prevK = k === -d || (k !== d && (vv[off + k - 1] ?? 0) < (vv[off + k + 1] ?? 0)) ? k + 1 : k - 1;
+        const prevX = vv[off + prevK] ?? 0;
+        const prevY = prevX - prevK;
+        while (x > prevX && y > prevY) {
+            ops.push({ t: ' ', line: A[--x] ?? '' });
+            y--;
+        }
+        if (x === prevX)
+            ops.push({ t: '+', line: B[--y] ?? '' });
+        else
+            ops.push({ t: '-', line: A[--x] ?? '' });
+    }
+    while (x > 0 && y > 0) {
+        ops.push({ t: ' ', line: A[--x] ?? '' });
+        y--;
+    }
+    ops.reverse();
+    return [...head, ...ops, ...tail];
+}
+/** a unified diff of two texts ("" when they're the same) */
+export function unifiedDiff(before, after, nameA = 'before', nameB = 'after', context = 3) {
+    const a = before.replace(/\r\n/g, '\n').split('\n');
+    const b = after.replace(/\r\n/g, '\n').split('\n');
+    const ops = diffLines(a, b);
+    if (!ops.some((o) => o.t !== ' '))
+        return '';
+    const out = [`--- a/${nameA}`, `+++ b/${nameB}`];
+    // walk the script, cutting it into hunks with `context` kept lines around each change
+    let i = 0;
+    let oa = 1, ob = 1;
+    const pos = ops.map((o) => {
+        const p = { a: oa, b: ob };
+        if (o.t !== '+')
+            oa++;
+        if (o.t !== '-')
+            ob++;
+        return p;
+    });
+    while (i < ops.length) {
+        while (i < ops.length && ops[i]?.t === ' ')
+            i++;
+        if (i >= ops.length)
+            break;
+        const from = Math.max(0, i - context);
+        let to = i;
+        let calm = 0;
+        while (to < ops.length) {
+            if (ops[to]?.t === ' ') {
+                calm++;
+                if (calm > context * 2)
+                    break;
+            }
+            else
+                calm = 0;
+            to++;
+        }
+        to = Math.min(ops.length, to - Math.max(0, calm - context));
+        const hunk = ops.slice(from, to);
+        const p = pos[from] ?? { a: 1, b: 1 };
+        const na = hunk.filter((o) => o.t !== '+').length;
+        const nb = hunk.filter((o) => o.t !== '-').length;
+        out.push(`@@ -${na ? p.a : p.a - 1},${na} +${nb ? p.b : p.b - 1},${nb} @@`);
+        for (const o of hunk)
+            out.push(o.t + o.line);
+        i = to;
+    }
+    return out.join('\n') + '\n';
+}

package/dist/fs/files.js

@@ -0,0 +1,233 @@
+// Paths inside the served folder, what is hidden, folder listings and raw file serving (with ranges).
+import fs from 'node:fs';
+import path from 'node:path';
+/** Folders a search or a file list skips when git can't say what is ignored. */
+export const NOISE = new Set(['node_modules', '.git', '.hg', '.svn', '.next', '.cache', '.turbo', '__pycache__', '.venv']);
+export function isSecret(name) {
+    if (name.startsWith('.env') && name !== '.env.example' && name !== '.env.sample')
+        return true;
+    if (/^id_(rsa|dsa|ecdsa|ed25519)(\.|$)/.test(name))
+        return true;
+    return /\.(key|pem|p12|pfx|keystore)$/i.test(name);
+}
+export function isHidden(scope, name) {
+    return scope.hidden.has(name) || (scope.hideSecrets && isSecret(name));
+}
+/** A root-relative path with forward slashes, no leading slash. */
+export function toRel(scope, abs) {
+    return path.relative(scope.root, abs).split(path.sep).join('/');
+}
+/** The absolute path for a root-relative one, or undefined when it leaves the root or touches something hidden. */
+export function inside(scope, rel) {
+    const clean = rel.replace(/\\/g, '/');
+    const abs = path.resolve(scope.root, '.' + path.sep + clean);
+    if (abs !== scope.root && !abs.startsWith(scope.root + path.sep))
+        return undefined;
+    const parts = path.relative(scope.root, abs).split(path.sep).filter(Boolean);
+    if (parts.some((p) => isHidden(scope, p)))
+        return undefined;
+    if (parts.length && scope.excluded(parts.join('/')))
+        return undefined;
+    // a link may point outside the root: follow it and check again
+    try {
+        const real = fs.realpathSync(abs);
+        const realRoot = fs.realpathSync(scope.root);
+        if (real !== realRoot && !real.startsWith(realRoot + path.sep))
+            return undefined;
+    }
+    catch {
+        // missing files are fine here (a deleted file's diff); the caller checks existence
+    }
+    return abs;
+}
+export function list(scope, rel) {
+    const abs = inside(scope, rel);
+    if (abs === undefined)
+        return undefined;
+    let dirents;
+    try {
+        dirents = fs.readdirSync(abs, { withFileTypes: true });
+    }
+    catch {
+        return undefined;
+    }
+    return dirents
+        .filter((e) => {
+        if (isHidden(scope, e.name))
+            return false;
+        const dir = toRel(scope, abs);
+        return !scope.excluded(dir ? dir + '/' + e.name : e.name, e.isDirectory());
+    })
+        .flatMap((e) => {
+        try {
+            const st = fs.statSync(path.join(abs, e.name));
+            const entry = { name: e.name, type: st.isDirectory() ? 'folder' : 'file', size: st.size, mtime: st.mtimeMs };
+            if (e.isSymbolicLink())
+                entry.link = true;
+            return [entry];
+        }
+        catch {
+            return []; // a broken link, or removed while listing
+        }
+    });
+}
+export const RAW_TYPES = {
+    png: 'image/png',
+    jpg: 'image/jpeg',
+    jpeg: 'image/jpeg',
+    gif: 'image/gif',
+    webp: 'image/webp',
+    avif: 'image/avif',
+    svg: 'image/svg+xml',
+    ico: 'image/x-icon',
+    bmp: 'image/bmp',
+    mp3: 'audio/mpeg',
+    ogg: 'audio/ogg',
+    oga: 'audio/ogg',
+    wav: 'audio/wav',
+    flac: 'audio/flac',
+    m4a: 'audio/mp4',
+    aac: 'audio/aac',
+    opus: 'audio/ogg',
+    mp4: 'video/mp4',
+    m4v: 'video/mp4',
+    webm: 'video/webm',
+    ogv: 'video/ogg',
+    mov: 'video/quicktime',
+    pdf: 'application/pdf',
+    woff: 'font/woff',
+    woff2: 'font/woff2',
+    ttf: 'font/ttf',
+    otf: 'font/otf',
+    json: 'application/json; charset=utf-8',
+    wasm: 'application/wasm',
+};
+/** Any file the page shows: never run as a page on this origin (except a sandboxed HTML preview). */
+const RAW_CSP = "default-src 'none'; img-src 'self' data:; style-src 'unsafe-inline'; media-src 'self'; font-src 'self'";
+/** An HTML preview: sandboxed (no scripts, its own origin), may load its own images and styles. */
+const PREVIEW_CSP = "sandbox; default-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'none'";
+export function serveRaw(scope, rel, req, res, asPage) {
+    const abs = inside(scope, rel);
+    let st;
+    try {
+        st = abs === undefined ? undefined : fs.statSync(abs);
+    }
+    catch {
+        st = undefined;
+    }
+    if (abs === undefined || st === undefined || !st.isFile()) {
+        res.writeHead(404, { 'content-type': 'text/plain' }).end('not found');
+        return;
+    }
+    const ext = path.extname(abs).slice(1).toLowerCase();
+    const type = asPage && /^html?$/.test(ext) ? 'text/html; charset=utf-8' : (RAW_TYPES[ext] ?? 'text/plain; charset=utf-8');
+    // the browser keeps a copy and asks again cheaply: unchanged files answer 304 with no body
+    const etag = `W/"${st.size.toString(36)}-${Math.floor(st.mtimeMs).toString(36)}"`;
+    if (req.headers['if-none-match'] === etag && !req.headers.range) {
+        res.writeHead(304, { etag, 'cache-control': 'no-cache' }).end();
+        return;
+    }
+    const headers = {
+        'content-type': type,
+        'cache-control': 'no-cache',
+        etag,
+        'accept-ranges': 'bytes',
+        'x-content-type-options': 'nosniff',
+        'content-security-policy': asPage ? PREVIEW_CSP : RAW_CSP,
+    };
+    const range = /^bytes=(\d*)-(\d*)$/.exec(String(req.headers.range ?? ''));
+    if (range && (range[1] || range[2])) {
+        let start = range[1] ? Number(range[1]) : Math.max(0, st.size - Number(range[2]));
+        let end = range[1] && range[2] ? Number(range[2]) : st.size - 1;
+        end = Math.min(end, st.size - 1);
+        if (start > end || start >= st.size) {
+            res.writeHead(416, { 'content-range': `bytes */${st.size}` }).end();
+            return;
+        }
+        start = Math.max(0, start);
+        res.writeHead(206, { ...headers, 'content-range': `bytes ${start}-${end}/${st.size}`, 'content-length': String(end - start + 1) });
+        if (req.method === 'HEAD')
+            return void res.end();
+        fs.createReadStream(abs, { start, end }).pipe(res);
+        return;
+    }
+    res.writeHead(200, { ...headers, 'content-length': String(st.size) });
+    if (req.method === 'HEAD')
+        return void res.end();
+    fs.createReadStream(abs).pipe(res);
+}
+/** Every file under the root (root-relative), skipping hidden names and the usual noise folders. */
+export function walk(scope, limit = 200_000) {
+    const out = [];
+    const stack = [''];
+    while (stack.length && out.length < limit) {
+        const rel = stack.pop() ?? '';
+        let dirents;
+        try {
+            dirents = fs.readdirSync(path.join(scope.root, rel), { withFileTypes: true });
+        }
+        catch {
+            continue;
+        }
+        for (const d of dirents) {
+            if (isHidden(scope, d.name) || NOISE.has(d.name))
+                continue;
+            const p = rel ? rel + '/' + d.name : d.name;
+            if (scope.excluded(p, d.isDirectory()))
+                continue;
+            if (d.isDirectory())
+                stack.push(p);
+            else if (d.isFile())
+                out.push(p);
+        }
+    }
+    return out.sort();
+}
+/** A text file's contents (for a review item or a question's file block), cut to a line range if asked. */
+export function readText(scope, rel, lines, maxBytes) {
+    const abs = inside(scope, rel);
+    if (!abs)
+        return { error: 'Not available', status: 404 };
+    let st;
+    try {
+        st = fs.statSync(abs);
+    }
+    catch {
+        return { error: `No file ${rel}`, status: 404 };
+    }
+    if (!st.isFile())
+        return { error: `${rel} isn't a file`, status: 400 };
+    const buf = readHead(abs, lines ? Math.max(maxBytes, 50 * 1048576) : maxBytes);
+    if (buf.subarray(0, 8000).includes(0))
+        return { error: `${rel} is a binary file`, status: 415 };
+    let text = buf.toString('utf8');
+    const all = text.split(/\r?\n/);
+    const m = /^(\d+)(?:-(\d+))?$/.exec(lines);
+    let first = 1;
+    if (m) {
+        first = Math.max(1, Number(m[1]));
+        const last = Math.min(all.length, m[2] ? Number(m[2]) : first);
+        text = all.slice(first - 1, last).join('\n');
+    }
+    const truncated = !m && st.size > maxBytes;
+    return { text, size: st.size, first, total: all.length, truncated, mtime: st.mtimeMs };
+}
+/** the first `max` bytes of a file, without reading the rest */
+export function readHead(abs, max) {
+    const fd = fs.openSync(abs, 'r');
+    try {
+        const size = fs.fstatSync(fd).size;
+        const buf = Buffer.alloc(Math.min(size, max));
+        let off = 0;
+        while (off < buf.length) {
+            const n = fs.readSync(fd, buf, off, buf.length - off, off);
+            if (!n)
+                break;
+            off += n;
+        }
+        return buf.subarray(0, off);
+    }
+    finally {
+        fs.closeSync(fd);
+    }
+}