From 5dd26fb417ba19daeec36ddbd0c036c91712fe8c Mon Sep 17 00:00:00 2001
From: Alex Collins <alex_collins@intuit.com>
Date: Wed, 12 Aug 2026 14:06:24 -0700
Subject: [PATCH 1/5] feat: load diffs incrementally per repository

Add per-repo API endpoints and parallel frontend loading so diffs appear as each repo finishes, with command logging, 30s timeouts, and a depth-2 repo scan limit.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 diffs.html  | 168 +++++++++++++++++++++++++++++++++++++++++++++-------
 exec.go     |  68 +++++++++++++++++++++
 handlers.go | 127 +++++++++++++++++----------------------
 repos.go    |  75 +++++++++++++++++++++++
 4 files changed, 343 insertions(+), 95 deletions(-)
 create mode 100644 exec.go
 create mode 100644 repos.go
diff --git a/diffs.html b/diffs.html
index 5efda6c..385a608 100644
--- a/diffs.html
+++ b/diffs.html
@@ -1,5 +1,5 @@
 <!doctype html>
-<html>
+<html lang="en">
     <head>
         <meta charset="UTF-8" />
         <meta name="viewport" content="width=device-width, initial-scale=1.0" />
@@ -13,44 +13,170 @@
         />
         <link
             rel="stylesheet"
-            type="text/css"
-            href="https://cdn.jsdelivr.net/npm/diff2html@3.4.48/bundles/css/diff2html.min.css"
-            integrity="sha384-iBvSlI3tNrrSIy7s6mvLg+5B2Z/QXbR4L0Pzg1nRf8zkXrz5JF316MLm2igMIpi2"
+            href="https://cdn.jsdelivr.net/npm/diff2html@3.4.56/bundles/css/diff2html.min.css"
+            integrity="sha384-PdRCG/+r1waybtXfuDB9Kmv2h7AGoN6WaTZ5OF+ctPeR9BGne0FaKRQnUeGV4nDL"
             crossorigin="anonymous"
         />
+        <style>
+            body {
+                margin: 0 auto;
+                max-width: 1200px;
+                padding: 1.5rem;
+                background: #f6f8fa;
+                color: #1f2328;
+                font: 14px/1.5 system-ui, sans-serif;
+            }
+
+            h1 {
+                margin: 0 0 1rem;
+                font-size: 1.25rem;
+                font-weight: 600;
+            }
+
+            #message {
+                margin-bottom: 1rem;
+                color: #656d76;
+            }
+
+            #message.error {
+                color: #cf222e;
+            }
+
+            #diffs {
+                display: flex;
+                flex-direction: column;
+                gap: 1rem;
+            }
+
+            .repo {
+                overflow: hidden;
+                border: 1px solid #d0d7de;
+                border-radius: 8px;
+                background: #fff;
+            }
+
+            .repo h2 {
+                margin: 0;
+                padding: 0.75rem 1rem;
+                border-bottom: 1px solid #d0d7de;
+                background: #f6f8fa;
+                font-size: 0.875rem;
+                font-weight: 600;
+                word-break: break-all;
+            }
+
+            .repo .d2h-wrapper {
+                margin: 0;
+            }
+
+            .repo .d2h-file-wrapper {
+                border: 0;
+                border-radius: 0;
+                margin: 0;
+            }
+
+            .repo .d2h-file-header {
+                border-top: 1px solid #d0d7de;
+            }
+
+            .repo .d2h-file-wrapper:first-child .d2h-file-header {
+                border-top: 0;
+            }
+
+            .d2h-code-line-ctn {
+                font-family: ui-monospace, monospace;
+                font-size: 12px;
+                word-break: break-word;
+            }
+        </style>
     </head>
     <body>
+        <h1>Git Diffs</h1>
         <div id="message">Loading diffs...</div>
         <div id="diffs"></div>
 
         <script
-            type="text/javascript"
-            src="https://cdn.jsdelivr.net/npm/diff2html@3.4.48/bundles/js/diff2html-ui.min.js"
-            integrity="sha384-99bAn+VpNpavq3FarkwuSuDPDHMeakTiNqxxz3ezwdGUr414srIXY3YmXjaAkYne"
+            src="https://cdn.jsdelivr.net/npm/diff2html@3.4.56/bundles/js/diff2html-ui.min.js"
+            integrity="sha384-NRd5i/CwvZ20mJEQt3yaDU1LeU+tu0bqyVYojXi8d7Lf1B0/TIs2K3FTvlf8aO7p"
             crossorigin="anonymous"
         ></script>
         <script>
             const message = document.getElementById("message");
             const diffs = document.getElementById("diffs");
-            let currentDiff = "";
 
             async function fetchAndRender() {
+                message.className = "";
+                message.textContent = "Loading diffs...";
+
                 try {
-                    const response = await fetch("/diffs", {
-                        headers: { Accept: "text/x-diff" },
-                    });
-                    const data = await response.text();
-
-                    if (data !== currentDiff) {
-                        currentDiff = data;
-                        await new Diff2HtmlUI(diffs, currentDiff).draw();
-                        message.innerHTML = "";
+                    const reposResponse = await fetch("/repos");
+                    if (!reposResponse.ok) {
+                        throw new Error("Failed to list repositories");
+                    }
+
+                    const repos = await reposResponse.json();
+                    diffs.innerHTML = "";
+
+                    if (repos.length === 0) {
+                        message.textContent = "No git repositories found.";
+                        return;
                     }
+
+                    let completed = 0;
+                    let changedRepos = 0;
+
+                    await Promise.all(
+                        repos.map(async (repo) => {
+                            const response = await fetch(
+                                "/diff?repo=" + encodeURIComponent(repo),
+                                { headers: { Accept: "text/x-diff" } },
+                            );
+                            if (!response.ok) {
+                                throw new Error(
+                                    "Failed to load diff for " + repo,
+                                );
+                            }
+
+                            const data = await response.text();
+                            completed++;
+                            message.textContent =
+                                "Loading diffs... (" +
+                                completed +
+                                "/" +
+                                repos.length +
+                                ")";
+
+                            if (!data.trim()) {
+                                return;
+                            }
+
+                            changedRepos++;
+
+                            const section = document.createElement("section");
+                            section.className = "repo";
+
+                            const title = document.createElement("h2");
+                            title.textContent = repo;
+                            section.appendChild(title);
+
+                            const container = document.createElement("div");
+                            section.appendChild(container);
+                            diffs.appendChild(section);
+
+                            new Diff2HtmlUI(container, data).draw();
+                        }),
+                    );
+
+                    if (changedRepos === 0) {
+                        message.textContent = "No uncommitted changes.";
+                        return;
+                    }
+
+                    message.textContent = "";
                 } catch (error) {
-                    message.innerHTML =
-                        "<div>Error fetching diffs: " +
-                        error.message +
-                        "</div>";
+                    message.className = "error";
+                    message.textContent =
+                        "Error fetching diffs: " + error.message;
                 }
             }
 
diff --git a/exec.go b/exec.go
new file mode 100644
index 0000000..99ea02a
--- /dev/null
+++ b/exec.go
@@ -0,0 +1,68 @@
+package main
+
+import (
+	"context"
+	"io"
+	"log"
+	"os/exec"
+	"strings"
+	"time"
+)
+
+const commandTimeout = 30 * time.Second
+
+func runCommand(ctx context.Context, dir string, stdout, stderr io.Writer, name string, args ...string) error {
+	ctx, cancel := context.WithTimeout(ctx, commandTimeout)
+	defer cancel()
+
+	cmdLine := name
+	if len(args) > 0 {
+		cmdLine += " " + strings.Join(args, " ")
+	}
+	if name == "bash" && len(args) >= 2 && args[0] == "-c" {
+		cmdLine = "bash -c <script>"
+	}
+	log.Printf("executing: %s (dir=%s)", cmdLine, dir)
+
+	start := time.Now()
+
+	cmd := exec.CommandContext(ctx, name, args...)
+	cmd.Dir = dir
+	cmd.Stdout = stdout
+	cmd.Stderr = stderr
+
+	err := cmd.Run()
+	duration := time.Since(start).Round(time.Millisecond)
+	if err != nil {
+		log.Printf("command finished after %s with error (dir=%s): %v", duration, dir, err)
+		return err
+	}
+
+	log.Printf("command finished in %s (dir=%s)", duration, dir)
+	return nil
+}
+
+func gitDiffScript(repoName string) string {
+	return `
+DEFAULT_BRANCH=""
+if git rev-parse --verify main >/dev/null 2>&1; then
+  DEFAULT_BRANCH="main"
+elif git rev-parse --verify master >/dev/null 2>&1; then
+  DEFAULT_BRANCH="master"
+fi
+
+CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
+
+if [ -n "$DEFAULT_BRANCH" ] && [ -n "$CURRENT_BRANCH" ] && [ "$CURRENT_BRANCH" != "$DEFAULT_BRANCH" ]; then
+  git diff --src-prefix=a/` + repoName + `/ --dst-prefix=b/` + repoName + `/ ${DEFAULT_BRANCH}...HEAD
+else
+  git diff --src-prefix=a/` + repoName + `/ --dst-prefix=b/` + repoName + `/ HEAD
+fi
+
+git ls-files --others --exclude-standard | while IFS= read -r file; do
+  if [ -n "$file" ]; then
+    git diff --no-index --src-prefix=a/` + repoName + `/ --dst-prefix=b/` + repoName + `/ /dev/null "$file" 2>/dev/null || true
+  fi
+done
+`
+}
diff --git a/handlers.go b/handlers.go
index 6ee3a0d..cdbcc22 100644
--- a/handlers.go
+++ b/handlers.go
@@ -2,26 +2,31 @@ package main
 
 import (
 	"context"
+	"encoding/json"
 	_ "embed"
+	"io"
 	"log"
 	"net/http"
-	"os"
-	"os/exec"
-	"path/filepath"
 	"strings"
-	"time"
 )
 
 //go:embed diffs.html
 var diffsHTML []byte
 
 func diffsHandler(w http.ResponseWriter, r *http.Request) {
-	accept := r.Header.Get("Accept")
-
-	if strings.Contains(accept, "text/x-diff") {
-		serveDiffsText(w, r)
-	} else {
-		serveDiffsHTML(w, r)
+	switch r.URL.Path {
+	case "/repos":
+		serveRepos(w, r)
+	case "/diff":
+		serveRepoDiff(w, r)
+	case "/":
+		if strings.Contains(r.Header.Get("Accept"), "text/x-diff") {
+			serveDiffsText(w, r)
+		} else {
+			serveDiffsHTML(w, r)
+		}
+	default:
+		http.NotFound(w, r)
 	}
 }
 
@@ -32,30 +37,49 @@ func serveDiffsHTML(w http.ResponseWriter, _ *http.Request) {
 	}
 }
 
-func findGitRepos(root string) ([]string, error) {
-	var repos []string
+func serveRepos(w http.ResponseWriter, r *http.Request) {
+	repos, err := findGitRepos(".")
+	if err != nil {
+		http.Error(w, "Failed to find git repositories: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
 
-	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
-		if err != nil {
-			return nil
-		}
+	names := make([]string, 0, len(repos))
+	for _, repoPath := range repos {
+		names = append(names, repoDisplayName(repoPath))
+	}
 
-		if info.IsDir() && info.Name() == ".git" {
-			repoPath := filepath.Dir(path)
-			repos = append(repos, repoPath)
-			return filepath.SkipDir
-		}
+	w.Header().Set("Content-Type", "application/json; charset=utf-8")
+	if err := json.NewEncoder(w).Encode(names); err != nil {
+		log.Printf("Failed to encode repos response: %v", err)
+	}
+}
+
+func serveRepoDiff(w http.ResponseWriter, r *http.Request) {
+	repoName := r.URL.Query().Get("repo")
+	if repoName == "" {
+		http.Error(w, "missing repo query parameter", http.StatusBadRequest)
+		return
+	}
 
-		return nil
-	})
+	repoPath, err := resolveRepoPath(repoName)
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusNotFound)
+		return
+	}
+
+	w.Header().Set("Content-Type", "text/x-diff; charset=utf-8")
+	if err := writeRepoDiff(r.Context(), w, repoPath); err != nil {
+		log.Printf("Failed to write diff for %s: %v", repoPath, err)
+	}
+}
 
-	return repos, err
+func writeRepoDiff(ctx context.Context, w io.Writer, repoPath string) error {
+	repoName := repoDisplayName(repoPath)
+	return runCommand(ctx, repoPath, w, w, "bash", "-c", gitDiffScript(repoName))
 }
 
 func serveDiffsText(w http.ResponseWriter, r *http.Request) {
-	ctx, cancel := context.WithTimeout(r.Context(), 3*time.Second)
-	defer cancel()
-
 	writer := &maxSizeWriter{Writer: w, maxSize: 5 * 1024 * 1024}
 
 	repos, err := findGitRepos(".")
@@ -67,53 +91,8 @@ func serveDiffsText(w http.ResponseWriter, r *http.Request) {
 	w.Header().Set("Content-Type", "text/x-diff; charset=utf-8")
 
 	for _, repoPath := range repos {
-		relPath, err := filepath.Rel(".", repoPath)
-		if err != nil {
-			log.Printf("Failed to get relative path for %s: %v", repoPath, err)
-			relPath = repoPath
-		}
-		if relPath == "." {
-			relPath = ""
-		}
-
-		repoName := relPath
-		if repoName == "" {
-			repoName = filepath.Base(repoPath)
-		}
-
-		cmd := exec.CommandContext(ctx, "bash", "-c", `
-# Determine the default branch (main or master)
-DEFAULT_BRANCH=""
-if git rev-parse --verify main >/dev/null 2>&1; then
-  DEFAULT_BRANCH="main"
-elif git rev-parse --verify master >/dev/null 2>&1; then
-  DEFAULT_BRANCH="master"
-fi
-
-# Get current branch
-CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
-
-# Determine what to diff against
-if [ -n "$DEFAULT_BRANCH" ] && [ -n "$CURRENT_BRANCH" ] && [ "$CURRENT_BRANCH" != "$DEFAULT_BRANCH" ]; then
-  # On a feature branch: show all changes from branch point
-  git diff --src-prefix=a/`+repoName+`/ --dst-prefix=b/`+repoName+`/ ${DEFAULT_BRANCH}...HEAD
-else
-  # On default branch or detached HEAD: show only uncommitted changes
-  git diff --src-prefix=a/`+repoName+`/ --dst-prefix=b/`+repoName+`/ HEAD
-fi
-
-# Always show untracked files
-git ls-files --others --exclude-standard | while IFS= read -r file; do
-  if [ -n "$file" ]; then
-    git diff --no-index --src-prefix=a/`+repoName+`/ --dst-prefix=b/`+repoName+`/ /dev/null "$file" 2>/dev/null || true
-  fi
-done
-		`)
-		cmd.Dir = repoPath
-		cmd.Stdout = writer
-		cmd.Stderr = writer
-		if err := cmd.Run(); err != nil {
-			log.Printf("Git command failed for %s: %v", repoPath, err)
+		if err := writeRepoDiff(r.Context(), writer, repoPath); err != nil {
+			continue
 		}
 	}
 }
diff --git a/repos.go b/repos.go
new file mode 100644
index 0000000..87e607f
--- /dev/null
+++ b/repos.go
@@ -0,0 +1,75 @@
+package main
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+const maxRepoDepth = 2
+
+func pathDepth(rel string) int {
+	rel = filepath.ToSlash(rel)
+	if rel == "." {
+		return 0
+	}
+	return strings.Count(rel, "/") + 1
+}
+
+func findGitRepos(root string) ([]string, error) {
+	var repos []string
+	root = filepath.Clean(root)
+
+	err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
+		if err != nil {
+			return nil
+		}
+
+		rel, err := filepath.Rel(root, path)
+		if err != nil {
+			return nil
+		}
+
+		if info.IsDir() && info.Name() == ".git" {
+			repoPath := filepath.Dir(path)
+			repoRel, err := filepath.Rel(root, repoPath)
+			if err != nil {
+				return nil
+			}
+			if pathDepth(repoRel) <= maxRepoDepth {
+				repos = append(repos, repoPath)
+			}
+			return filepath.SkipDir
+		}
+
+		if info.IsDir() && pathDepth(rel) > maxRepoDepth {
+			return filepath.SkipDir
+		}
+
+		return nil
+	})
+
+	return repos, err
+}
+
+func repoDisplayName(repoPath string) string {
+	relPath, err := filepath.Rel(".", repoPath)
+	if err != nil || relPath == "." {
+		return filepath.Base(repoPath)
+	}
+	return relPath
+}
+
+func resolveRepoPath(name string) (string, error) {
+	repos, err := findGitRepos(".")
+	if err != nil {
+		return "", err
+	}
+	for _, repoPath := range repos {
+		if repoDisplayName(repoPath) == name {
+			return repoPath, nil
+		}
+	}
+	return "", fmt.Errorf("unknown repo: %s", name)
+}

From 21703795db53e2c24e16f48d4e38ef329e03c83c Mon Sep 17 00:00:00 2001
From: Alex Collins <alex_collins@intuit.com>
Date: Wed, 12 Aug 2026 14:10:10 -0700
Subject: [PATCH 2/5] refactor: centralize diff UI styling in CSS variables

Use design tokens and scoped diff2html overrides so the page stays visually consistent as the UI evolves.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 diffs.html | 61 ++++++++++++++++++++++++++++++++++++------------------
 1 file changed, 41 insertions(+), 20 deletions(-)

diff --git a/diffs.html b/diffs.html
index 385a608..7a7d4c7 100644
--- a/diffs.html
+++ b/diffs.html
@@ -18,53 +18,74 @@
             crossorigin="anonymous"
         />
         <style>
+            :root {
+                --bg: #f6f8fa;
+                --surface: #fff;
+                --border: #d0d7de;
+                --text: #1f2328;
+                --muted: #656d76;
+                --danger: #cf222e;
+                --radius: 8px;
+                --space: 1rem;
+                --space-sm: 0.75rem;
+                --max-width: 1200px;
+                --font: system-ui, sans-serif;
+                --mono: ui-monospace, monospace;
+                --font-size: 14px;
+                --font-size-sm: 0.875rem;
+                --font-size-code: 12px;
+            }
+
+            /* app chrome */
             body {
                 margin: 0 auto;
-                max-width: 1200px;
+                max-width: var(--max-width);
                 padding: 1.5rem;
-                background: #f6f8fa;
-                color: #1f2328;
-                font: 14px/1.5 system-ui, sans-serif;
+                background: var(--bg);
+                color: var(--text);
+                font: var(--font-size) / 1.5 var(--font);
             }
 
             h1 {
-                margin: 0 0 1rem;
+                margin: 0 0 var(--space);
                 font-size: 1.25rem;
                 font-weight: 600;
             }
 
             #message {
-                margin-bottom: 1rem;
-                color: #656d76;
+                margin-bottom: var(--space);
+                color: var(--muted);
             }
 
             #message.error {
-                color: #cf222e;
+                color: var(--danger);
             }
 
             #diffs {
                 display: flex;
                 flex-direction: column;
-                gap: 1rem;
+                gap: var(--space);
             }
 
+            /* card */
             .repo {
                 overflow: hidden;
-                border: 1px solid #d0d7de;
-                border-radius: 8px;
-                background: #fff;
+                border: 1px solid var(--border);
+                border-radius: var(--radius);
+                background: var(--surface);
             }
 
             .repo h2 {
                 margin: 0;
-                padding: 0.75rem 1rem;
-                border-bottom: 1px solid #d0d7de;
-                background: #f6f8fa;
-                font-size: 0.875rem;
+                padding: var(--space-sm) var(--space);
+                border-bottom: 1px solid var(--border);
+                background: var(--bg);
+                font-size: var(--font-size-sm);
                 font-weight: 600;
                 word-break: break-all;
             }
 
+            /* diff2html overrides */
             .repo .d2h-wrapper {
                 margin: 0;
             }
@@ -76,16 +97,16 @@
             }
 
             .repo .d2h-file-header {
-                border-top: 1px solid #d0d7de;
+                border-top: 1px solid var(--border);
             }
 
             .repo .d2h-file-wrapper:first-child .d2h-file-header {
                 border-top: 0;
             }
 
-            .d2h-code-line-ctn {
-                font-family: ui-monospace, monospace;
-                font-size: 12px;
+            .repo .d2h-code-line-ctn {
+                font-family: var(--mono);
+                font-size: var(--font-size-code);
                 word-break: break-word;
             }
         </style>

From e231f8ccbbbccfadb27e8f7cfc439ebad1741adb Mon Sep 17 00:00:00 2001
From: Alex Collins <alex_collins@intuit.com>
Date: Wed, 12 Aug 2026 14:15:03 -0700
Subject: [PATCH 3/5] feat: persist viewed files with hash-based invalidation

Remember collapsed files in localStorage keyed by repo and path, and reset viewed state when a file's diff content changes.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 diffs.html | 185 ++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 177 insertions(+), 8 deletions(-)

diff --git a/diffs.html b/diffs.html
index 7a7d4c7..449367d 100644
--- a/diffs.html
+++ b/diffs.html
@@ -124,6 +124,148 @@ <h1>Git Diffs</h1>
         <script>
             const message = document.getElementById("message");
             const diffs = document.getElementById("diffs");
+            const VIEWED_KEY = "diff-server-viewed";
+            const repoSections = new Map();
+
+            const viewedStore = {
+                load() {
+                    try {
+                        return JSON.parse(
+                            localStorage.getItem(VIEWED_KEY) ?? "{}",
+                        );
+                    } catch {
+                        return {};
+                    }
+                },
+                save(state) {
+                    localStorage.setItem(VIEWED_KEY, JSON.stringify(state));
+                },
+            };
+
+            async function hashText(text) {
+                const buf = await crypto.subtle.digest(
+                    "SHA-256",
+                    new TextEncoder().encode(text),
+                );
+                return Array.from(new Uint8Array(buf), (b) =>
+                    b.toString(16).padStart(2, "0"),
+                ).join("");
+            }
+
+            function parseFileDiffs(diffText) {
+                const files = new Map();
+                for (const chunk of diffText.split(/\n(?=diff --git )/)) {
+                    if (!chunk.startsWith("diff --git ")) {
+                        continue;
+                    }
+                    const match = chunk.match(
+                        /^diff --git a\/(.+?) b\/(.+)$/m,
+                    );
+                    if (!match) {
+                        continue;
+                    }
+                    files.set(match[2], chunk);
+                }
+                return files;
+            }
+
+            function fileKey(repo, path) {
+                return repo + ":" + path;
+            }
+
+            function setFileViewed(wrapper, viewed) {
+                const checkbox = wrapper.querySelector('input[name="viewed"]');
+                const collapse = wrapper.querySelector(".d2h-file-collapse");
+                const contents = wrapper.querySelector(
+                    ".d2h-file-diff, .d2h-files-diff",
+                );
+                if (!checkbox || !collapse || !contents) {
+                    return;
+                }
+                checkbox.checked = viewed;
+                collapse.classList.toggle("d2h-selected", viewed);
+                contents.classList.toggle("d2h-d-none", viewed);
+            }
+
+            async function applyViewedState(repo, container, diffText, state) {
+                const fileDiffs = parseFileDiffs(diffText);
+                const entries = [...fileDiffs.entries()];
+                const hashes = new Map(
+                    await Promise.all(
+                        entries.map(async ([path, chunk]) => [
+                            path,
+                            await hashText(chunk),
+                        ]),
+                    ),
+                );
+                const wrappers = container.querySelectorAll(".d2h-file-wrapper");
+
+                wrappers.forEach((wrapper, index) => {
+                    const path = entries[index]?.[0];
+                    if (!path) {
+                        return;
+                    }
+
+                    const hash = hashes.get(path);
+                    const key = fileKey(repo, path);
+                    const checkbox = wrapper.querySelector('input[name="viewed"]');
+                    if (!checkbox) {
+                        return;
+                    }
+
+                    checkbox.addEventListener("change", () => {
+                        if (checkbox.checked && hash) {
+                            state[key] = hash;
+                        } else {
+                            delete state[key];
+                        }
+                        viewedStore.save(state);
+                    });
+
+                    if (hash && state[key] === hash) {
+                        setFileViewed(wrapper, true);
+                    }
+                });
+            }
+
+            function pruneViewedState(state, sections) {
+                const validKeys = new Set();
+                for (const [repo, entry] of sections) {
+                    for (const path of parseFileDiffs(entry.diffText).keys()) {
+                        validKeys.add(fileKey(repo, path));
+                    }
+                }
+
+                for (const key of Object.keys(state)) {
+                    if (!validKeys.has(key)) {
+                        delete state[key];
+                    }
+                }
+            }
+
+            function removeRepoSection(repo) {
+                const entry = repoSections.get(repo);
+                if (!entry) {
+                    return;
+                }
+                entry.section.remove();
+                repoSections.delete(repo);
+            }
+
+            function renderRepoSection(repo) {
+                const section = document.createElement("section");
+                section.className = "repo";
+
+                const title = document.createElement("h2");
+                title.textContent = repo;
+                section.appendChild(title);
+
+                const container = document.createElement("div");
+                container.className = "repo-diff";
+                section.appendChild(container);
+
+                return { section, container };
+            }
 
             async function fetchAndRender() {
                 message.className = "";
@@ -136,9 +278,20 @@ <h1>Git Diffs</h1>
                     }
 
                     const repos = await reposResponse.json();
-                    diffs.innerHTML = "";
+                    const viewedState = viewedStore.load();
+                    const activeRepos = new Set(repos);
+
+                    for (const repo of repoSections.keys()) {
+                        if (!activeRepos.has(repo)) {
+                            removeRepoSection(repo);
+                        }
+                    }
 
                     if (repos.length === 0) {
+                        diffs.innerHTML = "";
+                        repoSections.clear();
+                        pruneViewedState(viewedState, repoSections);
+                        viewedStore.save(viewedState);
                         message.textContent = "No git repositories found.";
                         return;
                     }
@@ -168,27 +321,43 @@ <h1>Git Diffs</h1>
                                 ")";
 
                             if (!data.trim()) {
+                                removeRepoSection(repo);
                                 return;
                             }
 
                             changedRepos++;
 
-                            const section = document.createElement("section");
-                            section.className = "repo";
+                            const existing = repoSections.get(repo);
+                            if (existing && existing.diffText === data) {
+                                return;
+                            }
 
-                            const title = document.createElement("h2");
-                            title.textContent = repo;
-                            section.appendChild(title);
+                            removeRepoSection(repo);
 
-                            const container = document.createElement("div");
-                            section.appendChild(container);
+                            const { section, container } =
+                                renderRepoSection(repo);
                             diffs.appendChild(section);
 
                             new Diff2HtmlUI(container, data).draw();
+                            await applyViewedState(
+                                repo,
+                                container,
+                                data,
+                                viewedState,
+                            );
+                            repoSections.set(repo, {
+                                diffText: data,
+                                section,
+                            });
                         }),
                     );
 
+                    pruneViewedState(viewedState, repoSections);
+                    viewedStore.save(viewedState);
+
                     if (changedRepos === 0) {
+                        diffs.innerHTML = "";
+                        repoSections.clear();
                         message.textContent = "No uncommitted changes.";
                         return;
                     }

From b5008222bd0891240c13a31db893de52c4c6409f Mon Sep 17 00:00:00 2001
From: Alex Collins <alexec@users.noreply.github.com>
Date: Wed, 12 Aug 2026 14:22:01 -0700
Subject: [PATCH 4/5] Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>
---
 handlers.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/handlers.go b/handlers.go
index cdbcc22..64abf46 100644
--- a/handlers.go
+++ b/handlers.go
@@ -76,7 +76,7 @@ func serveRepoDiff(w http.ResponseWriter, r *http.Request) {
 
 func writeRepoDiff(ctx context.Context, w io.Writer, repoPath string) error {
 	repoName := repoDisplayName(repoPath)
-	return runCommand(ctx, repoPath, w, w, "bash", "-c", gitDiffScript(repoName))
+	return runCommand(ctx, repoPath, w, io.Discard, "bash", "-c", gitDiffScript(), "--", repoName)
 }
 
 func serveDiffsText(w http.ResponseWriter, r *http.Request) {

From cfaeaa1e02578875077bf1f8b08a6532fef34ef0 Mon Sep 17 00:00:00 2001
From: Alex Collins <alex_collins@intuit.com>
Date: Wed, 12 Aug 2026 14:28:45 -0700
Subject: [PATCH 5/5] fix: address PR review feedback for incremental diff
 loading

Cap per-repo diff responses, resolve repos without repeated walks, pass repo names safely to bash, and continue loading when individual repos fail.

Co-authored-by: Cursor <cursoragent@cursor.com>
---
 diffs.html  | 84 ++++++++++++++++++++++++++++-------------------------
 exec.go     |  9 +++---
 handlers.go |  5 ++--
 repos.go    | 29 ++++++++++++++----
 4 files changed, 76 insertions(+), 51 deletions(-)

diff --git a/diffs.html b/diffs.html
index 449367d..228a8cf 100644
--- a/diffs.html
+++ b/diffs.html
@@ -301,54 +301,58 @@ <h1>Git Diffs</h1>
 
                     await Promise.all(
                         repos.map(async (repo) => {
-                            const response = await fetch(
-                                "/diff?repo=" + encodeURIComponent(repo),
-                                { headers: { Accept: "text/x-diff" } },
-                            );
-                            if (!response.ok) {
-                                throw new Error(
-                                    "Failed to load diff for " + repo,
+                            try {
+                                const response = await fetch(
+                                    "/diff?repo=" + encodeURIComponent(repo),
+                                    { headers: { Accept: "text/x-diff" } },
                                 );
-                            }
 
-                            const data = await response.text();
-                            completed++;
-                            message.textContent =
-                                "Loading diffs... (" +
-                                completed +
-                                "/" +
-                                repos.length +
-                                ")";
+                                if (!response.ok) {
+                                    return;
+                                }
+
+                                const data = await response.text();
+
+                                if (!data.trim()) {
+                                    removeRepoSection(repo);
+                                    return;
+                                }
+
+                                changedRepos++;
+
+                                const existing = repoSections.get(repo);
+                                if (existing && existing.diffText === data) {
+                                    return;
+                                }
 
-                            if (!data.trim()) {
                                 removeRepoSection(repo);
-                                return;
-                            }
 
-                            changedRepos++;
+                                const { section, container } =
+                                    renderRepoSection(repo);
+                                diffs.appendChild(section);
 
-                            const existing = repoSections.get(repo);
-                            if (existing && existing.diffText === data) {
+                                new Diff2HtmlUI(container, data).draw();
+                                await applyViewedState(
+                                    repo,
+                                    container,
+                                    data,
+                                    viewedState,
+                                );
+                                repoSections.set(repo, {
+                                    diffText: data,
+                                    section,
+                                });
+                            } catch {
                                 return;
+                            } finally {
+                                completed++;
+                                message.textContent =
+                                    "Loading diffs... (" +
+                                    completed +
+                                    "/" +
+                                    repos.length +
+                                    ")";
                             }
-
-                            removeRepoSection(repo);
-
-                            const { section, container } =
-                                renderRepoSection(repo);
-                            diffs.appendChild(section);
-
-                            new Diff2HtmlUI(container, data).draw();
-                            await applyViewedState(
-                                repo,
-                                container,
-                                data,
-                                viewedState,
-                            );
-                            repoSections.set(repo, {
-                                diffText: data,
-                                section,
-                            });
                         }),
                     );
 
diff --git a/exec.go b/exec.go
index 99ea02a..d890504 100644
--- a/exec.go
+++ b/exec.go
@@ -42,8 +42,9 @@ func runCommand(ctx context.Context, dir string, stdout, stderr io.Writer, name
 	return nil
 }
 
-func gitDiffScript(repoName string) string {
+func gitDiffScript() string {
 	return `
+REPO_NAME="$1"
 DEFAULT_BRANCH=""
 if git rev-parse --verify main >/dev/null 2>&1; then
   DEFAULT_BRANCH="main"
@@ -54,14 +55,14 @@ fi
 CURRENT_BRANCH=$(git symbolic-ref --short HEAD 2>/dev/null || echo "")
 
 if [ -n "$DEFAULT_BRANCH" ] && [ -n "$CURRENT_BRANCH" ] && [ "$CURRENT_BRANCH" != "$DEFAULT_BRANCH" ]; then
-  git diff --src-prefix=a/` + repoName + `/ --dst-prefix=b/` + repoName + `/ ${DEFAULT_BRANCH}...HEAD
+  git diff --src-prefix="a/${REPO_NAME}/" --dst-prefix="b/${REPO_NAME}/" ${DEFAULT_BRANCH}...HEAD
 else
-  git diff --src-prefix=a/` + repoName + `/ --dst-prefix=b/` + repoName + `/ HEAD
+  git diff --src-prefix="a/${REPO_NAME}/" --dst-prefix="b/${REPO_NAME}/" HEAD
 fi
 
 git ls-files --others --exclude-standard | while IFS= read -r file; do
   if [ -n "$file" ]; then
-    git diff --no-index --src-prefix=a/` + repoName + `/ --dst-prefix=b/` + repoName + `/ /dev/null "$file" 2>/dev/null || true
+    git diff --no-index --src-prefix="a/${REPO_NAME}/" --dst-prefix="b/${REPO_NAME}/" /dev/null "$file" 2>/dev/null || true
   fi
 done
 `
diff --git a/handlers.go b/handlers.go
index 64abf46..bdbcbb7 100644
--- a/handlers.go
+++ b/handlers.go
@@ -69,14 +69,15 @@ func serveRepoDiff(w http.ResponseWriter, r *http.Request) {
 	}
 
 	w.Header().Set("Content-Type", "text/x-diff; charset=utf-8")
-	if err := writeRepoDiff(r.Context(), w, repoPath); err != nil {
+	writer := &maxSizeWriter{Writer: w, maxSize: 5 * 1024 * 1024}
+	if err := writeRepoDiff(r.Context(), writer, repoPath); err != nil {
 		log.Printf("Failed to write diff for %s: %v", repoPath, err)
 	}
 }
 
 func writeRepoDiff(ctx context.Context, w io.Writer, repoPath string) error {
 	repoName := repoDisplayName(repoPath)
-	return runCommand(ctx, repoPath, w, io.Discard, "bash", "-c", gitDiffScript(), "--", repoName)
+	return runCommand(ctx, repoPath, w, io.Discard, "bash", "-c", gitDiffScript(), "bash", repoName)
 }
 
 func serveDiffsText(w http.ResponseWriter, r *http.Request) {
diff --git a/repos.go b/repos.go
index 87e607f..d684600 100644
--- a/repos.go
+++ b/repos.go
@@ -62,14 +62,33 @@ func repoDisplayName(repoPath string) string {
 }
 
 func resolveRepoPath(name string) (string, error) {
-	repos, err := findGitRepos(".")
+	cwd, err := os.Getwd()
 	if err != nil {
 		return "", err
 	}
-	for _, repoPath := range repos {
-		if repoDisplayName(repoPath) == name {
-			return repoPath, nil
+
+	if name == filepath.Base(cwd) {
+		if _, err := os.Stat(filepath.Join(".", ".git")); err == nil {
+			return ".", nil
 		}
 	}
-	return "", fmt.Errorf("unknown repo: %s", name)
+
+	candidate := filepath.Clean(name)
+	if candidate == ".." || strings.HasPrefix(candidate, "../") {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	if _, err := os.Stat(filepath.Join(candidate, ".git")); err != nil {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	if pathDepth(candidate) > maxRepoDepth {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	if repoDisplayName(candidate) != name {
+		return "", fmt.Errorf("unknown repo: %s", name)
+	}
+
+	return candidate, nil
 }
