codereviewr 1.0.0

package/README.md

@@ -0,0 +1,140 @@
+# codereview
+
+A local code review tool for humans reviewing AI-generated changes. Point it at a git repo (or a directory of repos), browse diffs in your browser, leave inline comments, and generate structured markdown feedback you can paste back into your agent session.
+
+## Install
+
+Requires [Bun](https://bun.sh) to build, runs on Node.js or Bun.
+
+```bash
+# Clone and install globally
+git clone https://github.com/jhaynie/codereview.git
+cd codereview
+bun install
+bun run build
+npm link
+```
+
+Now `codereview` is available globally.
+
+## Usage
+
+```bash
+# Review uncommitted changes in the current directory
+codereview
+
+# Review a specific repo
+codereview /path/to/repo
+
+# Review all changes on your branch vs main
+codereview --base main
+
+# Review a multi-repo worktree
+codereview /path/to/worktree
+```
+
+The tool opens a browser UI and exits automatically when you close the tab.
+
+### Options
+
+| Flag                | Description                                                                                                     |
+| ------------------- | --------------------------------------------------------------------------------------------------------------- |
+| `-b, --base <ref>`  | Diff against a base branch (e.g., `main`). Shows all committed + uncommitted changes since the branch diverged. |
+| `-p, --port <port>` | Run the UI on a specific port. Default: random available port.                                                  |
+| `-h, --help`        | Show help.                                                                                                      |
+
+### Multi-Repo Mode
+
+If the target directory isn't a git repo but contains subdirectories that are, codereview automatically enters multi-repo mode. Files are grouped by repo in the sidebar, and each repo's branch is tracked independently.
+
+```
+worktree/
+  api-server/.git
+  web-client/.git
+  shared-lib/.git
+```
+
+```bash
+codereview /path/to/worktree --base main
+```
+
+## How It Works
+
+1. **Browse** -- Files are listed in the left sidebar with status icons (A/M/D/R). Use arrow keys to navigate or click.
+2. **Review** -- The center panel shows the diff with syntax-colored additions and deletions. Collapsed sections between hunks can be expanded 10 lines at a time.
+3. **Comment** -- Click the `+` icon on any line to open an inline comment editor. Press `Cmd+Enter` to save. Comments appear below their line with a yellow accent bar.
+4. **Track** -- A comment count pill in the toolbar shows how many comments you've made. Click it to open a slideover panel listing all comments grouped by file. Click any comment to jump to it.
+5. **Generate** -- Hit the "Generate" button to produce markdown. An editable preview lets you tweak the output before copying to clipboard.
+
+### Generated Output
+
+The markdown is structured for pasting into an agent session:
+
+```
+Verify each finding against the current code and only fix it if needed.
+
+In `src/server.ts` around lines 42, this error case is unhandled
+
+In `src/api/auth.ts` around lines 108, the token refresh logic has a race condition
+```
+
+## Keyboard Shortcuts
+
+| Key         | Context                | Action           |
+| ----------- | ---------------------- | ---------------- |
+| `Up/Down`   | Sidebar                | Navigate files   |
+| `Left`      | Diff panel             | Focus sidebar    |
+| `Right`     | Sidebar                | Focus diff panel |
+| `+` click   | Diff line              | Add comment      |
+| `Cmd+Enter` | Comment editor         | Save comment     |
+| `Esc`       | Comment editor / modal | Cancel / close   |
+
+## UI Features
+
+- **Dark / Light / System theme** -- Toggle in the sidebar footer, persisted to localStorage
+- **Draggable sidebar** -- Resize the file list, width persisted across sessions
+- **Branch toggle** -- Switch between "dirty" (uncommitted only) and "vs main" (full branch diff) on the fly
+- **Diff stats** -- Each file header shows `+N` / `-N` line counts
+- **Expandable context** -- Hidden lines between hunks expand incrementally (10 at a time)
+
+### Default View
+
+![default](./images/defaultview.png)
+
+### Dark Mode
+
+![darkmode](./images/darkmode.png)
+
+### Leave Comments
+
+![comment](./images/comment.png)
+
+### Generate the Review Feedback
+
+![review](./images/review.png)
+
+### Supports Multi-Repo
+
+![multirepo](./images/multirepo.png)
+
+## Development
+
+```bash
+# Install deps
+bun install
+
+# Build (bundles frontend + CLI)
+bun run build
+
+# Run from built output
+node dist/cli.mjs /path/to/repo
+
+# Or run source directly with Bun during development
+bun src/cli.ts /path/to/repo
+```
+
+Note: Running source directly with `bun src/cli.ts` requires Bun and won't serve the pre-built frontend. Use `bun run build` first, then `node dist/cli.mjs` for the full experience.
+
+## License
+
+MIT

package/dist/cli.mjs

@@ -0,0 +1,457 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { parseArgs } from "node:util";
+import { createServer } from "node:http";
+import { readFile as readFile2, realpath } from "node:fs/promises";
+import { resolve as resolve2, join as join2, dirname, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { exec } from "node:child_process";
+
+// src/git.ts
+import { execFile } from "node:child_process";
+import { readFile, readdir } from "node:fs/promises";
+import { join, resolve } from "node:path";
+function git(args, cwd) {
+  return new Promise((resolve2, reject) => {
+    execFile("git", args, { cwd, maxBuffer: 50 * 1024 * 1024 }, (err, stdout) => {
+      if (err)
+        reject(err);
+      else
+        resolve2(stdout);
+    });
+  });
+}
+function gitSafe(args, cwd) {
+  return git(args, cwd).catch(() => "");
+}
+async function getRepoInfo(dir) {
+  let repo = "";
+  let branch = "";
+  try {
+    const remoteUrl = (await git(["config", "--get", "remote.origin.url"], dir)).trim();
+    const match = remoteUrl.match(/[:\/]([^\/]+\/[^\/]+?)(?:\.git)?$/);
+    repo = match ? match[1] : remoteUrl;
+  } catch {}
+  try {
+    branch = (await git(["rev-parse", "--abbrev-ref", "HEAD"], dir)).trim();
+  } catch {
+    branch = "unknown";
+  }
+  return { repo, branch };
+}
+async function isGitRepo(dir) {
+  try {
+    const toplevel = (await git(["rev-parse", "--show-toplevel"], dir)).trim();
+    return resolve(toplevel) === resolve(dir);
+  } catch {
+    return false;
+  }
+}
+async function getBranches(dir) {
+  try {
+    const output = (await git(["branch", "--format=%(refname:short)"], dir)).trim();
+    return output.split(`
+`).filter(Boolean);
+  } catch {
+    return [];
+  }
+}
+async function getMergeBase(dir, baseRef) {
+  return (await git(["merge-base", baseRef, "HEAD"], dir)).trim();
+}
+async function getChangedFiles(dir, baseRef) {
+  const files = [];
+  if (baseRef) {
+    const mergeBase = await getMergeBase(dir, baseRef);
+    const diffOutput = await git(["diff", "--name-status", mergeBase], dir);
+    for (const line of diffOutput.split(`
+`).filter(Boolean)) {
+      const parts = line.split("\t");
+      const statusCode = parts[0];
+      let fileStatus = "modified";
+      let oldPath;
+      let filePath = parts[1];
+      if (statusCode === "A") {
+        fileStatus = "added";
+      } else if (statusCode === "D") {
+        fileStatus = "deleted";
+      } else if (statusCode.startsWith("R")) {
+        fileStatus = "renamed";
+        oldPath = parts[1];
+        filePath = parts[2];
+      }
+      files.push({ path: filePath, status: fileStatus, oldPath });
+    }
+    const statusOutput = await gitSafe(["status", "--porcelain"], dir);
+    for (const line of statusOutput.split(`
+`).filter(Boolean)) {
+      const status = line.substring(0, 2).trim();
+      if (status === "??") {
+        const path = line.substring(3);
+        if (!files.some((f) => f.path === path)) {
+          files.push({ path, status: "added" });
+        }
+      }
+    }
+  } else {
+    const statusOutput = await git(["status", "--porcelain"], dir);
+    for (const line of statusOutput.split(`
+`).filter(Boolean)) {
+      const status = line.substring(0, 2).trim();
+      const path = line.substring(3);
+      let fileStatus = "modified";
+      let oldPath;
+      if (status === "A" || status === "??") {
+        fileStatus = "added";
+      } else if (status === "D") {
+        fileStatus = "deleted";
+      } else if (status.startsWith("R")) {
+        fileStatus = "renamed";
+        const parts = path.split(" -> ");
+        oldPath = parts[0];
+      }
+      files.push({
+        path: fileStatus === "renamed" ? path.split(" -> ")[1] : path,
+        status: fileStatus,
+        oldPath
+      });
+    }
+  }
+  return files;
+}
+async function readWorkingFile(dir, path) {
+  try {
+    return await readFile(join(dir, path), "utf-8");
+  } catch {
+    return "";
+  }
+}
+async function getFileDiff(dir, file, baseRef) {
+  let oldContent = "";
+  let newContent = "";
+  let hunks = [];
+  const oldRef = baseRef ? await getMergeBase(dir, baseRef) : "HEAD";
+  if (file.status === "added") {
+    try {
+      newContent = await git(["show", `:${file.path}`], dir);
+    } catch {
+      newContent = await readWorkingFile(dir, file.path);
+    }
+    oldContent = "";
+  } else if (file.status === "deleted") {
+    oldContent = await gitSafe(["show", `${oldRef}:${file.path}`], dir);
+    newContent = "";
+  } else {
+    oldContent = await gitSafe(["show", `${oldRef}:${file.path}`], dir);
+    newContent = await readWorkingFile(dir, file.path);
+    if (!newContent) {
+      try {
+        newContent = await git(["show", `:${file.path}`], dir);
+      } catch {
+        newContent = await gitSafe(["show", `HEAD:${file.path}`], dir);
+      }
+    }
+  }
+  if (file.status !== "added") {
+    try {
+      const diffResult = await git(["diff", oldRef, "--", file.path], dir);
+      hunks = parseDiffHunks(diffResult);
+    } catch {
+      hunks = [];
+    }
+  }
+  return {
+    path: file.path,
+    status: file.status,
+    oldPath: file.oldPath,
+    oldContent,
+    newContent,
+    hunks
+  };
+}
+async function getAllFileDiffs(dir, repo, baseRef) {
+  const files = await getChangedFiles(dir, baseRef);
+  const diffs = [];
+  for (const file of files) {
+    const diff = await getFileDiff(dir, file, baseRef);
+    if (repo)
+      diff.repo = repo;
+    diffs.push(diff);
+  }
+  return diffs;
+}
+async function discoverGitRepos(parentDir) {
+  const entries = await readdir(parentDir, { withFileTypes: true });
+  const repos = [];
+  for (const entry of entries) {
+    if (entry.isDirectory() && !entry.name.startsWith(".")) {
+      const subDir = join(parentDir, entry.name);
+      if (await isGitRepo(subDir)) {
+        repos.push(entry.name);
+      }
+    }
+  }
+  return repos.sort();
+}
+async function getMultiRepoDiffs(parentDir, repoNames, baseRef) {
+  const repos = [];
+  const allDiffs = [];
+  for (const name of repoNames) {
+    const repoDir = join(parentDir, name);
+    const info = await getRepoInfo(repoDir);
+    const diffs = await getAllFileDiffs(repoDir, name, baseRef);
+    if (diffs.length > 0) {
+      repos.push({ name, info });
+      allDiffs.push(...diffs);
+    }
+  }
+  return { repos, diffs: allDiffs };
+}
+function parseDiffHunks(diffOutput) {
+  const hunks = [];
+  const lines = diffOutput.split(`
+`);
+  let currentHunk = null;
+  let currentContent = [];
+  for (const line of lines) {
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch) {
+      if (currentHunk) {
+        currentHunk.content = currentContent.join(`
+`);
+        hunks.push(currentHunk);
+      }
+      currentHunk = {
+        oldStart: parseInt(hunkMatch[1]),
+        oldLines: parseInt(hunkMatch[2] || "1"),
+        newStart: parseInt(hunkMatch[3]),
+        newLines: parseInt(hunkMatch[4] || "1"),
+        content: ""
+      };
+      currentContent = [line];
+    } else if (currentHunk && (line.startsWith("+") || line.startsWith("-") || line.startsWith(" ") || line.startsWith("\\"))) {
+      currentContent.push(line);
+    }
+  }
+  if (currentHunk) {
+    currentHunk.content = currentContent.join(`
+`);
+    hunks.push(currentHunk);
+  }
+  return hunks;
+}
+
+// src/cli.ts
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var PUBLIC_DIR = join2(__dirname2, "public");
+var MIME = {
+  ".html": "text/html; charset=utf-8",
+  ".js": "application/javascript; charset=utf-8",
+  ".css": "text/css; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".svg": "image/svg+xml"
+};
+var state = {
+  diffs: [],
+  repos: [],
+  multiRepo: false,
+  repoNames: [],
+  workDir: process.cwd(),
+  baseRef: ""
+};
+async function loadDiffs(baseRef) {
+  const base = baseRef ?? state.baseRef;
+  state.baseRef = base;
+  if (state.multiRepo) {
+    const result = await getMultiRepoDiffs(state.workDir, state.repoNames, base || undefined);
+    state.repos = result.repos;
+    state.diffs = result.diffs;
+  } else {
+    const info = await getRepoInfo(state.workDir);
+    state.repos = [{ name: "", info }];
+    state.diffs = await getAllFileDiffs(state.workDir, undefined, base || undefined);
+  }
+}
+function jsonResponse(data, status = 200) {
+  return { status, headers: { "Content-Type": "application/json; charset=utf-8" }, body: JSON.stringify(data) };
+}
+async function readBody(req) {
+  const chunks = [];
+  for await (const chunk of req)
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  return Buffer.concat(chunks).toString("utf-8");
+}
+function generateMarkdown(comments) {
+  if (comments.length === 0)
+    return "";
+  const lines = ["Verify each finding against the current code and only fix it if needed.", ""];
+  for (const comment of comments) {
+    const filePath = comment.repo ? `${comment.repo}/${comment.filePath}` : comment.filePath;
+    lines.push(`In \`${filePath}\` around lines ${comment.lineNumber}, ${comment.content}`);
+    lines.push("");
+  }
+  return lines.join(`
+`);
+}
+async function main() {
+  const { values, positionals } = parseArgs({
+    args: process.argv.slice(2),
+    options: {
+      help: { type: "boolean", short: "h" },
+      port: { type: "string", short: "p", default: "" },
+      base: { type: "string", short: "b", default: "" }
+    },
+    allowPositionals: true
+  });
+  if (values.help) {
+    console.log(`
+codereview - A CLI tool for reviewing git changes
+
+Usage: codereview [options] [directory]
+
+Options:
+  -h, --help         Show this help message
+  -p, --port         Port to run the UI server (default: random available port)
+  -b, --base <ref>   Diff against a base branch (e.g., main). Shows all changes on the branch.
+                     Without this flag, only uncommitted changes are shown.
+
+Arguments:
+  directory          The git directory or parent of multiple git repos (default: current directory)
+`);
+    process.exit(0);
+  }
+  const targetDir = await realpath(resolve2(positionals[0] || process.cwd()));
+  state.workDir = targetDir;
+  state.baseRef = values.base || "";
+  if (await isGitRepo(targetDir)) {
+    state.multiRepo = false;
+    state.repoNames = [];
+  } else {
+    const repoNames = await discoverGitRepos(targetDir);
+    if (repoNames.length === 0) {
+      console.error(`Error: ${targetDir} is not a git repository and contains no git repos`);
+      process.exit(1);
+    }
+    console.log(`Found ${repoNames.length} repo(s): ${repoNames.join(", ")}`);
+    state.multiRepo = true;
+    state.repoNames = repoNames;
+  }
+  console.log(`Loading git changes${state.baseRef ? ` (base: ${state.baseRef})` : ""}...`);
+  await loadDiffs();
+  if (state.diffs.length === 0) {
+    console.log("No changes to review.");
+    process.exit(0);
+  }
+  const repoCount = state.repos.length;
+  console.log(`Found ${state.diffs.length} file(s) with changes${repoCount > 1 ? ` across ${repoCount} repos` : ""}.`);
+  const activeClients = new Set;
+  let shutdownTimer = null;
+  const SHUTDOWN_GRACE_MS = 500;
+  function onClientConnect(res) {
+    activeClients.add(res);
+    if (shutdownTimer) {
+      clearTimeout(shutdownTimer);
+      shutdownTimer = null;
+    }
+  }
+  function onClientDisconnect(res) {
+    activeClients.delete(res);
+    if (activeClients.size === 0 && !shutdownTimer) {
+      shutdownTimer = setTimeout(() => {
+        console.log("All clients disconnected. Shutting down.");
+        process.exit(0);
+      }, SHUTDOWN_GRACE_MS);
+    }
+  }
+  async function handleRequest(req) {
+    const url = new URL(req.url || "/", "http://localhost");
+    const path = url.pathname;
+    const method = req.method || "GET";
+    if (path === "/api/info" && method === "GET") {
+      return jsonResponse({ multiRepo: state.multiRepo, repos: state.repos, baseRef: state.baseRef });
+    }
+    if (path === "/api/diffs" && method === "GET") {
+      return jsonResponse(state.diffs);
+    }
+    if (path === "/api/branches" && method === "GET") {
+      if (state.multiRepo) {
+        let common = null;
+        for (const name of state.repoNames) {
+          const branches = new Set(await getBranches(join2(state.workDir, name)));
+          if (common === null) {
+            common = branches;
+          } else {
+            for (const b of common) {
+              if (!branches.has(b))
+                common.delete(b);
+            }
+          }
+        }
+        return jsonResponse({ branches: Array.from(common || []).sort() });
+      }
+      return jsonResponse({ branches: await getBranches(state.workDir) });
+    }
+    if (path === "/api/reload" && method === "POST") {
+      const body = JSON.parse(await readBody(req));
+      try {
+        await loadDiffs(body.base ?? "");
+        return jsonResponse({ success: true, fileCount: state.diffs.length, baseRef: state.baseRef, repos: state.repos });
+      } catch (err) {
+        return jsonResponse({ success: false, error: err.message }, 400);
+      }
+    }
+    if (path === "/api/generate-markdown" && method === "POST") {
+      const body = JSON.parse(await readBody(req));
+      return jsonResponse({ markdown: generateMarkdown(body.comments) });
+    }
+    const filePath = path === "/" ? "/index.html" : path;
+    try {
+      const content = await readFile2(join2(PUBLIC_DIR, filePath));
+      const mime = MIME[extname(filePath)] || "application/octet-stream";
+      return { status: 200, headers: { "Content-Type": mime }, body: content };
+    } catch {
+      return { status: 404, headers: { "Content-Type": "text/plain" }, body: "Not Found" };
+    }
+  }
+  const requestedPort = values.port ? parseInt(values.port) : 0;
+  const server = createServer(async (req, res) => {
+    if (req.url === "/api/keepalive" && req.method === "GET") {
+      res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      });
+      res.write(`data: connected
+
+`);
+      onClientConnect(res);
+      req.on("close", () => onClientDisconnect(res));
+      return;
+    }
+    try {
+      const { status, headers, body } = await handleRequest(req);
+      res.writeHead(status, headers);
+      res.end(body);
+    } catch (err) {
+      res.writeHead(500, { "Content-Type": "text/plain" });
+      res.end(`Internal Server Error: ${err.message}`);
+    }
+  });
+  server.listen(requestedPort, () => {
+    const addr = server.address();
+    const port = typeof addr === "object" && addr ? addr.port : requestedPort;
+    console.log(`
+Code review UI running at http://localhost:${port}`);
+    console.log(`Press Ctrl+C to stop.
+`);
+    if (process.env.NO_OPEN !== "true") {
+      const opener = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : "start";
+      exec(`${opener} http://localhost:${port}`, () => {});
+    }
+  });
+}
+main().catch((err) => {
+  console.error("Error:", err.message);
+  process.exit(1);
+});