repoview 0.1.0

package/public/app.js

@@ -0,0 +1,120 @@
+(() => {
+  const shouldWatch = new URLSearchParams(location.search).get("watch") !== "0";
+  if (!shouldWatch) return;
+
+  let pollingTimer = null;
+  let lastRevision = null;
+
+  async function fetchRevision() {
+    const res = await fetch(`/rev?ts=${Date.now()}`, { cache: "no-store" });
+    if (!res.ok) throw new Error("rev fetch failed");
+    const json = await res.json();
+    return Number(json.revision);
+  }
+
+  async function ensurePolling() {
+    if (pollingTimer) return;
+    try {
+      lastRevision = await fetchRevision();
+    } catch {
+      lastRevision = null;
+    }
+    pollingTimer = setInterval(async () => {
+      try {
+        const rev = await fetchRevision();
+        if (lastRevision != null && rev !== lastRevision) location.reload();
+        lastRevision = rev;
+      } catch {
+        // ignore
+      }
+    }, 2000);
+  }
+
+  try {
+    const es = new EventSource("/events");
+    es.addEventListener("reload", () => {
+      location.reload();
+    });
+    es.addEventListener("error", () => {
+      // Some environments/proxies break SSE; fall back to polling.
+      void ensurePolling();
+    });
+  } catch {
+    void ensurePolling();
+  }
+})();
+
+function preserveQueryParamsOnInternalLinks(keys) {
+  const current = new URLSearchParams(location.search);
+  const keep = new URLSearchParams();
+  for (const k of keys) {
+    const v = current.get(k);
+    if (v != null) keep.set(k, v);
+  }
+  if ([...keep.keys()].length === 0) return;
+
+  for (const a of document.querySelectorAll("a[href]")) {
+    const href = a.getAttribute("href");
+    if (!href) continue;
+    if (!href.startsWith("/")) continue;
+    if (href.startsWith("/static/")) continue;
+    if (href.startsWith("/events")) continue;
+
+    const noPreserve = String(a.getAttribute("data-no-preserve") || "")
+      .split(",")
+      .map((s) => s.trim())
+      .filter(Boolean);
+
+    try {
+      const u = new URL(href, location.origin);
+      for (const [k, v] of keep.entries()) {
+        if (noPreserve.includes(k)) continue;
+        if (!u.searchParams.has(k)) u.searchParams.set(k, v);
+      }
+      a.setAttribute("href", u.pathname + u.search + u.hash);
+    } catch {
+      // ignore
+    }
+  }
+}
+
+async function renderMermaid() {
+  const nodes = document.querySelectorAll(".mermaid");
+  if (!nodes.length) return;
+  try {
+    const mod = await import("/static/vendor/mermaid/mermaid.esm.min.mjs");
+    const mermaid = mod.default ?? mod.mermaid ?? mod;
+    mermaid.initialize?.({ startOnLoad: false, securityLevel: "strict" });
+    if (typeof mermaid.run === "function") {
+      await mermaid.run({ nodes });
+    }
+  } catch {
+    // Ignore; Mermaid is best-effort.
+  }
+}
+
+function renderMath() {
+  const root = document.querySelector(".markdown-body");
+  if (!root) return;
+  const renderMathInElement = window.renderMathInElement;
+  if (typeof renderMathInElement !== "function") return;
+  try {
+    renderMathInElement(root, {
+      delimiters: [
+        { left: "$$", right: "$$", display: true },
+        { left: "$", right: "$", display: false },
+        { left: "\\[", right: "\\]", display: true },
+        { left: "\\(", right: "\\)", display: false },
+      ],
+      throwOnError: false,
+    });
+  } catch {
+    // Ignore; KaTeX is best-effort.
+  }
+}
+
+window.addEventListener("load", () => {
+  preserveQueryParamsOnInternalLinks(["ignored", "watch"]);
+  renderMath();
+  renderMermaid();
+});

package/src/cli.js

@@ -0,0 +1,72 @@
+#!/usr/bin/env node
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { startServer } from "./server.js";
+
+function printHelp() {
+  // Keep this in sync with README.md
+  process.stdout.write(`repo-viewer
+
+Serve a local Git repository as a GitHub-like website.
+
+Usage:
+  npm start -- --repo /path/to/repo [--host 127.0.0.1] [--port 3000] [--no-watch]
+  node src/cli.js --repo /path/to/repo [--host 127.0.0.1] [--port 3000] [--no-watch]
+
+Options:
+  --repo <path>     Repository root (default: REPO_ROOT or project dir)
+  --host <host>     Bind address (default: 127.0.0.1)
+  --port <port>     Bind port (default: 3000)
+  --watch           Enable live reload (default)
+  --no-watch        Disable live reload
+  -h, --help        Show this help
+
+Environment:
+  REPO_ROOT, HOST, PORT
+`);
+}
+
+function parseArgs(argv) {
+  const args = { watch: true };
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const value = argv[i];
+    if (value === "-h" || value === "--help") args.help = true;
+    if (value === "--watch") args.watch = true;
+    else if (value === "--no-watch") args.watch = false;
+    else if (value === "--repo") args.repo = argv[++i];
+    else if (value === "--port") args.port = Number(argv[++i]);
+    else if (value === "--host") args.host = argv[++i];
+    else rest.push(value);
+  }
+  return { ...args, rest };
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const parsed = parseArgs(process.argv.slice(2));
+const { repo, port, host, watch, help } = parsed;
+
+if (help) {
+  printHelp();
+  process.exit(0);
+}
+
+if (port != null && !Number.isFinite(port)) {
+  process.stderr.write("Invalid --port value\n");
+  process.exit(2);
+}
+
+const repoRoot =
+  repo ??
+  process.env.REPO_ROOT ??
+  path.resolve(__dirname, "..");
+
+await startServer({
+  repoRoot,
+  port: port || Number(process.env.PORT) || 3000,
+  host: host || process.env.HOST || "127.0.0.1",
+  watch,
+});

package/src/gitignore.js

@@ -0,0 +1,34 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import ignore from "ignore";
+
+function toPosixPath(p) {
+  return p.split(path.sep).join("/");
+}
+
+export async function loadGitIgnoreMatcher(repoRootReal) {
+  const ig = ignore();
+
+  // Baseline ignores (never show these via toggle either).
+  ig.add([".git/"]);
+
+  try {
+    const content = await fs.readFile(path.join(repoRootReal, ".gitignore"), "utf8");
+    ig.add(content);
+  } catch {
+    // No .gitignore or unreadable; ignore.
+  }
+
+  return {
+    ignores(relPathPosix, { isDir = false } = {}) {
+      const p = toPosixPath(String(relPathPosix || "").replace(/^\/+/, ""));
+      if (!p) return false;
+      if (ig.ignores(p)) return true;
+      if (isDir) {
+        const withSlash = p.endsWith("/") ? p : `${p}/`;
+        if (ig.ignores(withSlash)) return true;
+      }
+      return false;
+    },
+  };
+}

package/src/linkcheck.js

@@ -0,0 +1,312 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+function toPosixPath(p) {
+  return p.split(path.sep).join("/");
+}
+
+function isWithinRoot(rootReal, candidateReal) {
+  if (candidateReal === rootReal) return true;
+  const rootWithSep = rootReal.endsWith(path.sep) ? rootReal : rootReal + path.sep;
+  return candidateReal.startsWith(rootWithSep);
+}
+
+async function safeResolveExisting(repoRootReal, relPosixPath) {
+  const stripped = String(relPosixPath || "").replace(/^\/+/, "");
+  const resolved = path.resolve(repoRootReal, stripped);
+  if (!isWithinRoot(repoRootReal, resolved)) {
+    return { ok: false, reason: "escape", resolved: null, type: null };
+  }
+
+  try {
+    await fs.lstat(resolved);
+  } catch {
+    return { ok: false, reason: "missing", resolved: null, type: null };
+  }
+
+  let real;
+  try {
+    real = await fs.realpath(resolved);
+  } catch {
+    return { ok: false, reason: "missing", resolved: null, type: null };
+  }
+  if (!isWithinRoot(repoRootReal, real)) {
+    return { ok: false, reason: "escape", resolved: null, type: null };
+  }
+
+  const stat = await fs.stat(real);
+  return {
+    ok: true,
+    reason: null,
+    resolved: real,
+    type: stat.isDirectory() ? "dir" : stat.isFile() ? "file" : "other",
+  };
+}
+
+function extractInternalUrlsFromHtml(html) {
+  const urls = [];
+  const re = /\b(?:href|src)=(["'])([^"']+)\1/gi;
+  let match;
+  while ((match = re.exec(html))) {
+    const raw = match[2].trim();
+    if (!raw || raw.startsWith("#")) continue;
+    urls.push(raw);
+  }
+  return urls;
+}
+
+function decodePosixPathFromUrlPath(urlPathname, prefix) {
+  const rest = urlPathname.slice(prefix.length);
+  const stripped = rest.replace(/^\/+/, "");
+  const segments = stripped.split("/").filter(Boolean);
+  try {
+    return segments.map((s) => decodeURIComponent(s)).join("/");
+  } catch {
+    return null;
+  }
+}
+
+function isMarkdownFile(relPosix) {
+  const lower = relPosix.toLowerCase();
+  const base = path.posix.basename(lower);
+  if (base === "readme" || base.startsWith("readme.")) return true;
+  const ext = path.posix.extname(lower).replace(/^\./, "");
+  return new Set(["md", "markdown", "mdown", "mkd", "mkdn"]).has(ext);
+}
+
+async function listMarkdownFiles(repoRootReal, { maxFiles, isIgnored } = {}) {
+  const results = [];
+  const stack = [{ abs: repoRootReal, relPosix: "" }];
+  const ignoredNames = new Set([".git", "node_modules"]);
+
+  while (stack.length) {
+    const { abs, relPosix } = stack.pop();
+    let entries;
+    try {
+      entries = await fs.readdir(abs, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const e of entries) {
+      if (ignoredNames.has(e.name)) continue;
+      const childAbs = path.join(abs, e.name);
+      const childRel = relPosix ? `${relPosix}/${e.name}` : e.name;
+      const childRelPosix = toPosixPath(childRel);
+
+      if (typeof isIgnored === "function" && isIgnored(childRelPosix, { isDir: e.isDirectory() }))
+        continue;
+
+      if (e.isDirectory()) {
+        stack.push({ abs: childAbs, relPosix: childRelPosix });
+      } else if (e.isFile()) {
+        if (isMarkdownFile(childRelPosix)) results.push(childRelPosix);
+        if (maxFiles && results.length >= maxFiles) return results;
+      }
+    }
+  }
+  results.sort();
+  return results;
+}
+
+export function createRepoLinkScanner({ repoRootReal, markdownRenderer, isIgnored }) {
+  let current = {
+    status: "idle",
+    lastResult: null,
+    lastError: null,
+    lastStartedAt: null,
+    lastFinishedAt: null,
+  };
+
+  let scanRunning = false;
+  let scanQueued = false;
+
+  async function scanOnce({
+    maxMarkdownFiles = 5000,
+    maxBytesPerFile = 2 * 1024 * 1024,
+    concurrency = 16,
+  } = {}) {
+    const startedAt = Date.now();
+    current = { ...current, status: "running", lastError: null, lastStartedAt: startedAt };
+
+    const markdownFiles = await listMarkdownFiles(repoRootReal, {
+      maxFiles: maxMarkdownFiles,
+      isIgnored,
+    });
+    const broken = [];
+    let filesScanned = 0;
+    let urlsChecked = 0;
+
+    const queue = markdownFiles.slice();
+    const workers = Array.from({ length: concurrency }, async () => {
+      while (queue.length) {
+        const relPosix = queue.pop();
+        if (!relPosix) return;
+
+        const abs = path.join(repoRootReal, relPosix);
+        let stat;
+        try {
+          stat = await fs.stat(abs);
+        } catch {
+          continue;
+        }
+        if (stat.size > maxBytesPerFile) continue;
+
+        let text;
+        try {
+          text = await fs.readFile(abs, "utf8");
+        } catch {
+          continue;
+        }
+
+        filesScanned++;
+        const baseDirPosix = path.posix.dirname(relPosix);
+        const env = { baseDirPosix: baseDirPosix === "." ? "" : baseDirPosix };
+        let html = "";
+        try {
+          html = markdownRenderer.render(text, env);
+        } catch {
+          continue;
+        }
+
+        const urls = extractInternalUrlsFromHtml(html);
+        for (const raw of urls) {
+          if (raw.startsWith("http://") || raw.startsWith("https://")) continue;
+          if (raw.startsWith("//")) continue;
+          if (raw.startsWith("mailto:") || raw.startsWith("tel:")) continue;
+          if (raw.startsWith("data:")) continue;
+          urlsChecked++;
+
+          let urlPath;
+          try {
+            urlPath = new URL(raw, "http://local").pathname;
+          } catch {
+            broken.push({
+              source: relPosix,
+              url: raw,
+              kind: "url",
+              reason: "invalid_url",
+            });
+            continue;
+          }
+
+          if (urlPath === "/events" || urlPath.startsWith("/static/")) continue;
+          if (urlPath === "/broken-links" || urlPath === "/broken-links.json") continue;
+
+          let expected = null;
+          let expectType = null;
+          if (urlPath.startsWith("/blob/")) {
+            expected = decodePosixPathFromUrlPath(urlPath, "/blob/");
+            expectType = "blob";
+          } else if (urlPath.startsWith("/tree/")) {
+            expected = decodePosixPathFromUrlPath(urlPath, "/tree/");
+            expectType = "tree";
+          } else if (urlPath.startsWith("/raw/")) {
+            expected = decodePosixPathFromUrlPath(urlPath, "/raw/");
+            expectType = "raw";
+          } else {
+            broken.push({
+              source: relPosix,
+              url: raw,
+              kind: "url",
+              reason: "unknown_route",
+            });
+            continue;
+          }
+
+          if (expected == null) {
+            broken.push({
+              source: relPosix,
+              url: raw,
+              kind: expectType,
+              reason: "bad_encoding",
+            });
+            continue;
+          }
+
+          if (typeof isIgnored === "function") {
+            if (expectType === "tree" && isIgnored(expected, { isDir: true })) continue;
+            if (expectType !== "tree" && isIgnored(expected, { isDir: false })) continue;
+          }
+
+          const resolved = await safeResolveExisting(repoRootReal, expected);
+          if (!resolved.ok) {
+            broken.push({
+              source: relPosix,
+              url: raw,
+              kind: expectType,
+              reason: resolved.reason,
+              target: expected,
+            });
+            continue;
+          }
+
+          if (expectType === "raw" && resolved.type !== "file") {
+            broken.push({
+              source: relPosix,
+              url: raw,
+              kind: expectType,
+              reason: "not_a_file",
+              target: expected,
+            });
+          } else if (expectType === "tree" && resolved.type !== "dir") {
+            broken.push({
+              source: relPosix,
+              url: raw,
+              kind: expectType,
+              reason: "not_a_directory",
+              target: expected,
+            });
+          }
+        }
+      }
+    });
+
+    await Promise.all(workers);
+
+    const finishedAt = Date.now();
+    const result = {
+      startedAt,
+      finishedAt,
+      durationMs: finishedAt - startedAt,
+      filesScanned,
+      urlsChecked,
+      broken: broken.sort((a, b) => a.source.localeCompare(b.source) || a.url.localeCompare(b.url)),
+    };
+
+    current = {
+      status: "idle",
+      lastResult: result,
+      lastError: null,
+      lastStartedAt: startedAt,
+      lastFinishedAt: finishedAt,
+    };
+    return result;
+  }
+
+  async function triggerScan(options) {
+    if (scanRunning) {
+      scanQueued = true;
+      return current;
+    }
+    scanRunning = true;
+    try {
+      await scanOnce(options);
+    } catch (e) {
+      current = { ...current, status: "idle", lastError: String(e?.message || e) };
+    } finally {
+      scanRunning = false;
+      if (scanQueued) {
+        scanQueued = false;
+        void triggerScan(options);
+      }
+    }
+    return current;
+  }
+
+  function getState() {
+    return current;
+  }
+
+  return { scanOnce, triggerScan, getState };
+}