diffity 0.1.0 → 0.1.1

package/dist/index.js

@@ -0,0 +1,1081 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { execSync as execSync3 } from "node:child_process";
+import { rmSync, existsSync as existsSync2 } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+import { createRequire } from "node:module";
+import open from "open";
+import pc2 from "picocolors";
+
+// ../git/dist/repo.js
+import { execSync as execSync2 } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+// ../git/dist/exec.js
+import { execSync } from "node:child_process";
+var STDIO = ["pipe", "pipe", "pipe"];
+function execWithStdin(cmd, input) {
+  return execSync(cmd, {
+    encoding: "utf-8",
+    stdio: STDIO,
+    input,
+    maxBuffer: 50 * 1024 * 1024
+  });
+}
+function exec(cmd) {
+  return execSync(cmd, {
+    encoding: "utf-8",
+    stdio: STDIO
+  }).trim();
+}
+function execLarge(cmd) {
+  return execSync(cmd, {
+    encoding: "utf-8",
+    stdio: STDIO,
+    maxBuffer: 50 * 1024 * 1024
+  });
+}
+function execLines(cmd) {
+  let output = exec(cmd);
+  return output ? output.split(`
+`) : [];
+}
+
+// ../git/dist/repo.js
+function isGitRepo() {
+  try {
+    return execSync2("git rev-parse --is-inside-work-tree", { stdio: "pipe" }), !0;
+  } catch {
+    return !1;
+  }
+}
+function getRepoRoot() {
+  return exec("git rev-parse --show-toplevel");
+}
+function getRepoName() {
+  let root = getRepoRoot();
+  return root.split("/").pop() || root;
+}
+function getCurrentBranch() {
+  try {
+    return exec("git rev-parse --abbrev-ref HEAD");
+  } catch {
+    return "HEAD";
+  }
+}
+function getRepoInfo() {
+  return {
+    name: getRepoName(),
+    branch: getCurrentBranch(),
+    root: getRepoRoot()
+  };
+}
+function getHeadHash() {
+  return exec("git rev-parse HEAD");
+}
+function getDiffityDirPath() {
+  let repoRoot = getRepoRoot(), hash = createHash("sha256").update(repoRoot).digest("hex").slice(0, 12);
+  return join(homedir(), ".diffity", hash);
+}
+function getDiffityDir() {
+  let dir = getDiffityDirPath();
+  return mkdirSync(dir, { recursive: !0 }), dir;
+}
+var ACTIONABLE_REFS = /* @__PURE__ */ new Set(["work", "staged", "unstaged", "working", "untracked"]);
+function isActionableRef(ref) {
+  return !!ref && ACTIONABLE_REFS.has(ref);
+}
+
+// ../git/dist/diff.js
+function getDiff(args = []) {
+  let cmd = ["git", "diff", ...args].join(" ");
+  return execLarge(cmd);
+}
+function getUntrackedFiles() {
+  return execLines("git ls-files --others --exclude-standard");
+}
+function getUntrackedDiff(files) {
+  let diffs = [];
+  for (let file of files)
+    try {
+      execLarge(`git diff --no-index -- /dev/null "${file}"`);
+    } catch (err) {
+      let error = err;
+      error.status === 1 && error.stdout && diffs.push(error.stdout);
+    }
+  return diffs.join(`
+`);
+}
+function resolveRef(ref, extraArgs = []) {
+  switch (ref) {
+    case "staged":
+      return getDiff(["--staged", ...extraArgs]);
+    case "unstaged":
+      return getDiff(extraArgs);
+    case "working":
+      return getDiff(["HEAD", ...extraArgs]);
+    case "untracked": {
+      let files = getUntrackedFiles();
+      return files.length === 0 ? "" : getUntrackedDiff(files);
+    }
+    case "work": {
+      let raw = getDiff(["HEAD", ...extraArgs]), untrackedFiles = getUntrackedFiles();
+      return untrackedFiles.length > 0 && (raw += `
+` + getUntrackedDiff(untrackedFiles)), raw;
+    }
+    default:
+      return getDiff([ref, ...extraArgs]);
+  }
+}
+function revertFile(filePath, isUntracked) {
+  isUntracked ? exec(`rm "${filePath}"`) : exec(`git checkout HEAD -- "${filePath}"`);
+}
+function revertHunk(patch) {
+  execWithStdin("git apply --reverse --unidiff-zero", patch);
+}
+function getDiffStat(args = []) {
+  let cmd = ["git", "diff", "--stat", ...args].join(" ");
+  try {
+    return execLarge(cmd);
+  } catch {
+    return "";
+  }
+}
+function getMergeBase(a, b) {
+  return exec(`git merge-base ${a} ${b}`);
+}
+function getFileContent(path, ref = "HEAD") {
+  return exec(`git show ${ref}:${path}`);
+}
+function getFileLineCount(path, ref = "HEAD") {
+  try {
+    return exec(`git show ${ref}:${path}`).split(`
+`).length;
+  } catch {
+    return null;
+  }
+}
+
+// ../git/dist/status.js
+function getStagedFiles() {
+  return execLines("git diff --staged --name-only");
+}
+function getUnstagedFiles() {
+  return execLines("git diff --name-only");
+}
+
+// ../git/dist/commits.js
+function getRecentCommits(query) {
+  let { count, skip = 0, search } = query, args = [`-n ${count}`, `--skip=${skip}`, '--format="%H|%h|%s|%cr"'];
+  search && args.push(`--grep=${search}`, "-i");
+  let output = exec(`git log ${args.join(" ")}`);
+  return output ? output.split(`
+`).map((line) => {
+    let [hash, shortHash, message, relativeDate] = line.split("|");
+    return { hash, shortHash, message, relativeDate };
+  }) : [];
+}
+
+// src/server.ts
+import { createServer } from "node:http";
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync2, existsSync } from "node:fs";
+import { join as join4, extname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { dirname } from "node:path";
+
+// ../parser/dist/word-diff.js
+function tokenize(text) {
+  let tokens = [], current = "";
+  for (let i = 0; i < text.length; i++) {
+    let char = text[i], isWordChar = /\w/.test(char);
+    if (current.length === 0) {
+      current = char;
+      continue;
+    }
+    let prevIsWordChar = /\w/.test(current[current.length - 1]);
+    isWordChar === prevIsWordChar ? current += char : (tokens.push(current), current = char);
+  }
+  return current.length > 0 && tokens.push(current), tokens;
+}
+function lcs(a, b) {
+  let m = a.length, n = b.length, dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
+  for (let i2 = 1; i2 <= m; i2++)
+    for (let j2 = 1; j2 <= n; j2++)
+      a[i2 - 1] === b[j2 - 1] ? dp[i2][j2] = dp[i2 - 1][j2 - 1] + 1 : dp[i2][j2] = Math.max(dp[i2 - 1][j2], dp[i2][j2 - 1]);
+  let result = [], i = m, j = n;
+  for (; i > 0 && j > 0; )
+    a[i - 1] === b[j - 1] ? (result.unshift([a[i - 1], "equal"]), i--, j--) : dp[i - 1][j] > dp[i][j - 1] ? i-- : j--;
+  return result;
+}
+function computeWordDiff(oldLine, newLine) {
+  if (oldLine === newLine)
+    return [{ text: oldLine, type: "equal" }];
+  if (oldLine.length === 0)
+    return [{ text: newLine, type: "insert" }];
+  if (newLine.length === 0)
+    return [{ text: oldLine, type: "delete" }];
+  let oldTokens = tokenize(oldLine), newTokens = tokenize(newLine), common = lcs(oldTokens, newTokens), segments = [], oi = 0, ni = 0, ci = 0;
+  for (; ci < common.length; ) {
+    let commonToken = common[ci][0], deleteText = "";
+    for (; oi < oldTokens.length && oldTokens[oi] !== commonToken; )
+      deleteText += oldTokens[oi], oi++;
+    let insertText = "";
+    for (; ni < newTokens.length && newTokens[ni] !== commonToken; )
+      insertText += newTokens[ni], ni++;
+    deleteText && segments.push({ text: deleteText, type: "delete" }), insertText && segments.push({ text: insertText, type: "insert" });
+    let equalText = "";
+    for (; oi < oldTokens.length && ni < newTokens.length && ci < common.length && oldTokens[oi] === common[ci][0] && newTokens[ni] === common[ci][0]; )
+      equalText += oldTokens[oi], oi++, ni++, ci++;
+    equalText && segments.push({ text: equalText, type: "equal" });
+  }
+  let trailingDelete = "";
+  for (; oi < oldTokens.length; )
+    trailingDelete += oldTokens[oi], oi++;
+  let trailingInsert = "";
+  for (; ni < newTokens.length; )
+    trailingInsert += newTokens[ni], ni++;
+  return trailingDelete && segments.push({ text: trailingDelete, type: "delete" }), trailingInsert && segments.push({ text: trailingInsert, type: "insert" }), segments;
+}
+
+// ../parser/dist/parse.js
+var DIFF_HEADER_RE = /^diff --git a\/(.*) b\/(.*)$/, HUNK_HEADER_RE = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@(.*)$/, OLD_FILE_RE = /^--- (.+)$/, NEW_FILE_RE = /^\+\+\+ (.+)$/, SIMILARITY_RE = /^similarity index (\d+)%$/, RENAME_FROM_RE = /^rename from (.+)$/, RENAME_TO_RE = /^rename to (.+)$/, COPY_FROM_RE = /^copy from (.+)$/, COPY_TO_RE = /^copy to (.+)$/, OLD_MODE_RE = /^old mode (\d+)$/, NEW_MODE_RE = /^new mode (\d+)$/, NEW_FILE_MODE_RE = /^new file mode (\d+)$/, DELETED_FILE_MODE_RE = /^deleted file mode (\d+)$/, BINARY_RE = /^Binary files (.+) and (.+) differ$/, NO_NEWLINE_RE = /^\$/;
+function stripPrefix(path) {
+  return path === "/dev/null" ? path : path.startsWith("a/") || path.startsWith("b/") ? path.slice(2) : path;
+}
+function attachWordDiffs(hunk) {
+  let lines = hunk.lines, i = 0;
+  for (; i < lines.length; )
+    if (lines[i].type === "delete") {
+      let deleteStart = i;
+      for (; i < lines.length && lines[i].type === "delete"; )
+        i++;
+      let deleteEnd = i, addStart = i;
+      for (; i < lines.length && lines[i].type === "add"; )
+        i++;
+      let addEnd = i, deleteCount = deleteEnd - deleteStart, addCount = addEnd - addStart;
+      if (deleteCount > 0 && addCount > 0) {
+        let pairCount = Math.min(deleteCount, addCount);
+        for (let p = 0; p < pairCount; p++) {
+          let delLine = lines[deleteStart + p], addLine = lines[addStart + p], segments = computeWordDiff(delLine.content, addLine.content);
+          delLine.wordDiff = segments, addLine.wordDiff = segments;
+        }
+      }
+    } else
+      i++;
+}
+function parseDiff(raw) {
+  let lines = raw.split(`
+`), files = [], currentFile = null, currentHunk = null, oldLineNum = 0, newLineNum = 0, i = 0;
+  for (; i < lines.length; ) {
+    let line = lines[i], diffMatch = line.match(DIFF_HEADER_RE);
+    if (diffMatch) {
+      currentFile && files.push(currentFile), currentFile = {
+        oldPath: diffMatch[1],
+        newPath: diffMatch[2],
+        status: "modified",
+        hunks: [],
+        additions: 0,
+        deletions: 0,
+        isBinary: !1
+      }, currentHunk = null, i++;
+      continue;
+    }
+    if (!currentFile) {
+      i++;
+      continue;
+    }
+    let oldModeMatch = line.match(OLD_MODE_RE);
+    if (oldModeMatch) {
+      currentFile.oldMode = oldModeMatch[1], i++;
+      continue;
+    }
+    let newModeMatch = line.match(NEW_MODE_RE);
+    if (newModeMatch) {
+      currentFile.newMode = newModeMatch[1], i++;
+      continue;
+    }
+    let newFileModeMatch = line.match(NEW_FILE_MODE_RE);
+    if (newFileModeMatch) {
+      currentFile.newMode = newFileModeMatch[1], currentFile.status = "added", i++;
+      continue;
+    }
+    let deletedFileModeMatch = line.match(DELETED_FILE_MODE_RE);
+    if (deletedFileModeMatch) {
+      currentFile.oldMode = deletedFileModeMatch[1], currentFile.status = "deleted", i++;
+      continue;
+    }
+    let similarityMatch = line.match(SIMILARITY_RE);
+    if (similarityMatch) {
+      currentFile.similarityIndex = parseInt(similarityMatch[1], 10), i++;
+      continue;
+    }
+    let renameFromMatch = line.match(RENAME_FROM_RE);
+    if (renameFromMatch) {
+      currentFile.oldPath = renameFromMatch[1], currentFile.status = "renamed", i++;
+      continue;
+    }
+    let renameToMatch = line.match(RENAME_TO_RE);
+    if (renameToMatch) {
+      currentFile.newPath = renameToMatch[1], currentFile.status = "renamed", i++;
+      continue;
+    }
+    let copyFromMatch = line.match(COPY_FROM_RE);
+    if (copyFromMatch) {
+      currentFile.oldPath = copyFromMatch[1], currentFile.status = "copied", i++;
+      continue;
+    }
+    let copyToMatch = line.match(COPY_TO_RE);
+    if (copyToMatch) {
+      currentFile.newPath = copyToMatch[1], currentFile.status = "copied", i++;
+      continue;
+    }
+    let oldFileMatch = line.match(OLD_FILE_RE);
+    if (oldFileMatch) {
+      let path = stripPrefix(oldFileMatch[1]);
+      currentFile.oldPath = path, path === "/dev/null" && (currentFile.status = "added"), i++;
+      continue;
+    }
+    let newFileMatch = line.match(NEW_FILE_RE);
+    if (newFileMatch) {
+      let path = stripPrefix(newFileMatch[1]);
+      currentFile.newPath = path, path === "/dev/null" && (currentFile.status = "deleted"), i++;
+      continue;
+    }
+    if (line.match(BINARY_RE)) {
+      currentFile.isBinary = !0, i++;
+      continue;
+    }
+    let hunkMatch = line.match(HUNK_HEADER_RE);
+    if (hunkMatch) {
+      currentHunk = {
+        header: line,
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldCount: hunkMatch[2] !== void 0 ? parseInt(hunkMatch[2], 10) : 1,
+        newStart: parseInt(hunkMatch[3], 10),
+        newCount: hunkMatch[4] !== void 0 ? parseInt(hunkMatch[4], 10) : 1,
+        context: hunkMatch[5]?.trim() || void 0,
+        lines: []
+      }, currentFile.hunks.push(currentHunk), oldLineNum = currentHunk.oldStart, newLineNum = currentHunk.newStart, i++;
+      continue;
+    }
+    if (NO_NEWLINE_RE.test(line)) {
+      currentHunk && currentHunk.lines.length > 0 && (currentHunk.lines[currentHunk.lines.length - 1].noNewline = !0), i++;
+      continue;
+    }
+    if (currentHunk) {
+      let prefix = line[0], content = line.slice(1);
+      if (prefix === "+") {
+        let diffLine = {
+          type: "add",
+          content,
+          oldLineNumber: null,
+          newLineNumber: newLineNum
+        };
+        currentHunk.lines.push(diffLine), currentFile.additions++, newLineNum++;
+      } else if (prefix === "-") {
+        let diffLine = {
+          type: "delete",
+          content,
+          oldLineNumber: oldLineNum,
+          newLineNumber: null
+        };
+        currentHunk.lines.push(diffLine), currentFile.deletions++, oldLineNum++;
+      } else if (prefix === " ") {
+        let diffLine = {
+          type: "context",
+          content: content || "",
+          oldLineNumber: oldLineNum,
+          newLineNumber: newLineNum
+        };
+        currentHunk.lines.push(diffLine), oldLineNum++, newLineNum++;
+      }
+    }
+    i++;
+  }
+  currentFile && files.push(currentFile);
+  for (let file of files)
+    for (let hunk of file.hunks)
+      attachWordDiffs(hunk);
+  let totalAdditions = 0, totalDeletions = 0;
+  for (let file of files)
+    totalAdditions += file.additions, totalDeletions += file.deletions;
+  return {
+    files,
+    stats: {
+      totalAdditions,
+      totalDeletions,
+      filesChanged: files.length
+    }
+  };
+}
+
+// src/session.ts
+import { randomUUID } from "node:crypto";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join as join3 } from "node:path";
+
+// src/db.ts
+import Database from "better-sqlite3";
+import { join as join2 } from "node:path";
+var db = null;
+function getDb() {
+  if (db)
+    return db;
+  let dbPath = join2(getDiffityDir(), "reviews.db");
+  return db = new Database(dbPath), db.pragma("journal_mode = WAL"), db.pragma("foreign_keys = ON"), migrateDb(db), db;
+}
+function migrateDb(db2) {
+  db2.exec(`
+    CREATE TABLE IF NOT EXISTS review_sessions (
+      id TEXT PRIMARY KEY,
+      ref TEXT NOT NULL,
+      head_hash TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS comment_threads (
+      id TEXT PRIMARY KEY,
+      session_id TEXT NOT NULL REFERENCES review_sessions(id),
+      file_path TEXT NOT NULL,
+      side TEXT NOT NULL,
+      start_line INTEGER NOT NULL,
+      end_line INTEGER NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      anchor_content TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS comments (
+      id TEXT PRIMARY KEY,
+      thread_id TEXT NOT NULL REFERENCES comment_threads(id) ON DELETE CASCADE,
+      author_name TEXT NOT NULL,
+      author_type TEXT NOT NULL,
+      body TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+  `);
+}
+
+// src/session.ts
+function sessionFilePath() {
+  return join3(getDiffityDir(), "current-session");
+}
+function findOrCreateSession(ref) {
+  let db2 = getDb(), headHash = getHeadHash(), existing = db2.prepare(
+    "SELECT id, ref, head_hash FROM review_sessions WHERE ref = ? AND head_hash = ?"
+  ).get(ref, headHash);
+  if (existing) {
+    let session2 = { id: existing.id, ref: existing.ref, headHash: existing.head_hash };
+    return writeFileSync(sessionFilePath(), JSON.stringify(session2)), session2;
+  }
+  let id = randomUUID();
+  db2.prepare(
+    "INSERT INTO review_sessions (id, ref, head_hash) VALUES (?, ?, ?)"
+  ).run(id, ref, headHash);
+  let session = { id, ref, headHash };
+  return writeFileSync(sessionFilePath(), JSON.stringify(session)), session;
+}
+function getCurrentSession() {
+  try {
+    let raw = readFileSync(sessionFilePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+// src/threads.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+function rowToThread(row, comments) {
+  return {
+    id: row.id,
+    sessionId: row.session_id,
+    filePath: row.file_path,
+    side: row.side,
+    startLine: row.start_line,
+    endLine: row.end_line,
+    status: row.status,
+    anchorContent: row.anchor_content,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+    comments
+  };
+}
+function rowToComment(row) {
+  return {
+    id: row.id,
+    author: { name: row.author_name, type: row.author_type },
+    body: row.body,
+    createdAt: row.created_at
+  };
+}
+function getCommentsForThreads(threadIds) {
+  if (threadIds.length === 0)
+    return /* @__PURE__ */ new Map();
+  let db2 = getDb(), placeholders = threadIds.map(() => "?").join(", "), rows = db2.prepare(
+    `SELECT * FROM comments WHERE thread_id IN (${placeholders}) ORDER BY created_at ASC`
+  ).all(...threadIds), map = /* @__PURE__ */ new Map();
+  for (let row of rows) {
+    let comments = map.get(row.thread_id) ?? [];
+    comments.push(rowToComment(row)), map.set(row.thread_id, comments);
+  }
+  return map;
+}
+function getCommentsForThread(threadId) {
+  return getCommentsForThreads([threadId]).get(threadId) ?? [];
+}
+function createThread(sessionId, filePath, side, startLine, endLine, body, author, anchorContent) {
+  let db2 = getDb(), threadId = randomUUID2(), commentId = randomUUID2(), now = (/* @__PURE__ */ new Date()).toISOString();
+  return db2.prepare(
+    "INSERT INTO comment_threads (id, session_id, file_path, side, start_line, end_line, anchor_content, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)"
+  ).run(threadId, sessionId, filePath, side, startLine, endLine, anchorContent ?? null, now, now), db2.prepare(
+    "INSERT INTO comments (id, thread_id, author_name, author_type, body, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(commentId, threadId, author.name, author.type, body, now), {
+    id: threadId,
+    sessionId,
+    filePath,
+    side,
+    startLine,
+    endLine,
+    status: "open",
+    anchorContent: anchorContent ?? null,
+    createdAt: now,
+    updatedAt: now,
+    comments: [{
+      id: commentId,
+      author,
+      body,
+      createdAt: now
+    }]
+  };
+}
+function getThreadsForSession(sessionId, status) {
+  let db2 = getDb(), rows;
+  status ? rows = db2.prepare(
+    "SELECT * FROM comment_threads WHERE session_id = ? AND status = ? ORDER BY created_at ASC"
+  ).all(sessionId, status) : rows = db2.prepare(
+    "SELECT * FROM comment_threads WHERE session_id = ? ORDER BY created_at ASC"
+  ).all(sessionId);
+  let commentsByThread = getCommentsForThreads(rows.map((r) => r.id));
+  return rows.map((row) => rowToThread(row, commentsByThread.get(row.id) ?? []));
+}
+function getThread(idOrPrefix) {
+  let db2 = getDb(), row = db2.prepare("SELECT * FROM comment_threads WHERE id = ?").get(idOrPrefix);
+  return !row && idOrPrefix.length >= 8 && (row = db2.prepare("SELECT * FROM comment_threads WHERE id LIKE ?").get(idOrPrefix + "%")), row ? rowToThread(row, getCommentsForThread(row.id)) : null;
+}
+function addReply(threadId, body, author) {
+  let db2 = getDb(), commentId = randomUUID2(), now = (/* @__PURE__ */ new Date()).toISOString();
+  return db2.prepare(
+    "INSERT INTO comments (id, thread_id, author_name, author_type, body, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+  ).run(commentId, threadId, author.name, author.type, body, now), db2.prepare(
+    "UPDATE comment_threads SET updated_at = ? WHERE id = ?"
+  ).run(now, threadId), {
+    id: commentId,
+    author,
+    body,
+    createdAt: now
+  };
+}
+function updateThreadStatus(threadId, status, summaryBody, summaryAuthor) {
+  let db2 = getDb(), now = (/* @__PURE__ */ new Date()).toISOString();
+  if (db2.prepare(
+    "UPDATE comment_threads SET status = ?, updated_at = ? WHERE id = ?"
+  ).run(status, now, threadId), summaryBody && summaryAuthor) {
+    let commentId = randomUUID2();
+    db2.prepare(
+      "INSERT INTO comments (id, thread_id, author_name, author_type, body, created_at) VALUES (?, ?, ?, ?, ?, ?)"
+    ).run(commentId, threadId, summaryAuthor.name, summaryAuthor.type, summaryBody, now);
+  }
+}
+function deleteThread(threadId) {
+  getDb().prepare("DELETE FROM comment_threads WHERE id = ?").run(threadId);
+}
+function deleteAllThreadsForSession(sessionId) {
+  getDb().prepare("DELETE FROM comment_threads WHERE session_id = ?").run(sessionId);
+}
+function deleteComment(commentId) {
+  let db2 = getDb(), comment = db2.prepare("SELECT thread_id FROM comments WHERE id = ?").get(commentId);
+  if (!comment)
+    return;
+  db2.prepare("DELETE FROM comments WHERE id = ?").run(commentId), db2.prepare("SELECT COUNT(*) as count FROM comments WHERE thread_id = ?").get(comment.thread_id).count === 0 && db2.prepare("DELETE FROM comment_threads WHERE id = ?").run(comment.thread_id);
+}
+
+// src/review-routes.ts
+function sendJson(res, data) {
+  res.writeHead(200, { "Content-Type": "application/json" }), res.end(JSON.stringify(data));
+}
+function sendError(res, status, message) {
+  res.writeHead(status, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: message }));
+}
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk)), req.on("end", () => resolve(Buffer.concat(chunks).toString())), req.on("error", reject);
+  });
+}
+function handleReviewRoute(req, res, pathname, url) {
+  if (pathname === "/api/sessions/current" && req.method === "GET") {
+    let session = getCurrentSession();
+    return sendJson(res, session), !0;
+  }
+  if (pathname === "/api/threads" && req.method === "GET") {
+    let sid = url.searchParams.get("session");
+    if (!sid)
+      return sendError(res, 400, "Missing session parameter"), !0;
+    let status = url.searchParams.get("status"), threads = getThreadsForSession(sid, status || void 0);
+    return sendJson(res, threads), !0;
+  }
+  if (pathname === "/api/threads" && req.method === "DELETE")
+    return readBody(req).then((raw) => {
+      try {
+        let body = JSON.parse(raw), { sessionId: sid } = body;
+        if (!sid) {
+          sendError(res, 400, "Missing sessionId");
+          return;
+        }
+        deleteAllThreadsForSession(sid), sendJson(res, { ok: !0 });
+      } catch (err) {
+        sendError(res, 500, `Failed to delete all threads: ${err}`);
+      }
+    }), !0;
+  if (pathname === "/api/threads" && req.method === "POST")
+    return readBody(req).then((raw) => {
+      try {
+        let body = JSON.parse(raw), { sessionId: sid, filePath, side, startLine, endLine, body: commentBody, author, anchorContent } = body;
+        if (!sid || !filePath || !side || typeof startLine != "number" || typeof endLine != "number" || !commentBody || !author) {
+          sendError(res, 400, "Missing required fields");
+          return;
+        }
+        let thread = createThread(sid, filePath, side, startLine, endLine, commentBody, author, anchorContent);
+        sendJson(res, thread);
+      } catch (err) {
+        sendError(res, 500, `Failed to create thread: ${err}`);
+      }
+    }), !0;
+  let threadReplyMatch = pathname.match(/^\/api\/threads\/([^/]+)\/reply$/);
+  if (threadReplyMatch && req.method === "POST")
+    return readBody(req).then((raw) => {
+      try {
+        let body = JSON.parse(raw), { body: commentBody, author } = body;
+        if (!commentBody || !author) {
+          sendError(res, 400, "Missing body or author");
+          return;
+        }
+        let comment = addReply(threadReplyMatch[1], commentBody, author);
+        sendJson(res, comment);
+      } catch (err) {
+        sendError(res, 500, `Failed to add reply: ${err}`);
+      }
+    }), !0;
+  let threadStatusMatch = pathname.match(/^\/api\/threads\/([^/]+)\/status$/);
+  if (threadStatusMatch && req.method === "PATCH")
+    return readBody(req).then((raw) => {
+      try {
+        let body = JSON.parse(raw), { status, summary } = body;
+        if (!status) {
+          sendError(res, 400, "Missing status");
+          return;
+        }
+        let summaryAuthor = summary ? { name: "System", type: "user" } : void 0;
+        updateThreadStatus(threadStatusMatch[1], status, summary, summaryAuthor), sendJson(res, { ok: !0 });
+      } catch (err) {
+        sendError(res, 500, `Failed to update thread status: ${err}`);
+      }
+    }), !0;
+  let threadDeleteMatch = pathname.match(/^\/api\/threads\/([^/]+)$/);
+  if (threadDeleteMatch && req.method === "DELETE") {
+    try {
+      deleteThread(threadDeleteMatch[1]), sendJson(res, { ok: !0 });
+    } catch (err) {
+      sendError(res, 500, `Failed to delete thread: ${err}`);
+    }
+    return !0;
+  }
+  let commentDeleteMatch = pathname.match(/^\/api\/comments\/([^/]+)$/);
+  if (commentDeleteMatch && req.method === "DELETE") {
+    try {
+      deleteComment(commentDeleteMatch[1]), sendJson(res, { ok: !0 });
+    } catch (err) {
+      sendError(res, 500, `Failed to delete comment: ${err}`);
+    }
+    return !0;
+  }
+  return !1;
+}
+
+// src/server.ts
+var __dirname = dirname(fileURLToPath(import.meta.url)), MIME_TYPES = {
+  ".html": "text/html",
+  ".js": "application/javascript",
+  ".css": "text/css",
+  ".json": "application/json",
+  ".svg": "image/svg+xml",
+  ".png": "image/png",
+  ".ico": "image/x-icon"
+};
+function sendJson2(res, data) {
+  res.writeHead(200, { "Content-Type": "application/json" }), res.end(JSON.stringify(data));
+}
+function sendError2(res, status, message) {
+  res.writeHead(status, { "Content-Type": "application/json" }), res.end(JSON.stringify({ error: message }));
+}
+function serveStatic(res, filePath) {
+  if (!existsSync(filePath)) {
+    sendError2(res, 404, "Not found");
+    return;
+  }
+  let ext = extname(filePath), mime = MIME_TYPES[ext] || "application/octet-stream", content = readFileSync2(filePath);
+  res.writeHead(200, { "Content-Type": mime }), res.end(content);
+}
+function descriptionForRef(ref) {
+  switch (ref) {
+    case "staged":
+      return "Staged changes";
+    case "unstaged":
+      return "Unstaged changes";
+    case "working":
+      return "Working tree changes";
+    case "untracked":
+      return "Untracked files";
+    case "work":
+      return "All changes";
+    default:
+      return ref.includes("..") ? ref : `Changes from ${ref}`;
+  }
+}
+function resolveBaseRef(ref) {
+  if (["staged", "working", "work"].includes(ref) || ref === "unstaged" || ref === "untracked")
+    return "HEAD";
+  let threeDotsIdx = ref.indexOf("...");
+  if (threeDotsIdx !== -1) {
+    let left = ref.slice(0, threeDotsIdx), right = ref.slice(threeDotsIdx + 3);
+    return getMergeBase(left, right);
+  }
+  let twoDotsIdx = ref.indexOf("..");
+  return twoDotsIdx !== -1 ? ref.slice(0, twoDotsIdx) : ref;
+}
+function readBody2(req) {
+  return new Promise((resolve, reject) => {
+    let chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk)), req.on("end", () => resolve(Buffer.concat(chunks).toString())), req.on("error", reject);
+  });
+}
+function startServer(options) {
+  let { port, diffArgs, description, effectiveRef } = options, sessionId = null, reviewsEnabled = isActionableRef(effectiveRef);
+  reviewsEnabled && effectiveRef && (sessionId = findOrCreateSession(effectiveRef).id);
+  let includeUntracked = diffArgs.length === 0;
+  function enrichWithLineCounts(diff, baseRef) {
+    for (let file of diff.files) {
+      if (file.status === "added" || file.isBinary)
+        continue;
+      let path = file.oldPath || file.newPath, count = getFileLineCount(path, baseRef);
+      count !== null && (file.oldFileLineCount = count);
+    }
+    return diff;
+  }
+  function getFullDiff(args) {
+    let raw = getDiff(args);
+    if (includeUntracked) {
+      let untrackedFiles = getUntrackedFiles();
+      untrackedFiles.length > 0 && (raw += `
+` + getUntrackedDiff(untrackedFiles));
+    }
+    return raw;
+  }
+  let uiDir = join4(__dirname, "ui"), server = createServer(async (req, res) => {
+    let url = new URL(req.url || "/", `http://localhost:${port}`), pathname = url.pathname;
+    if (res.setHeader("Access-Control-Allow-Origin", "*"), res.setHeader("Access-Control-Allow-Methods", "GET, POST, PATCH, DELETE, OPTIONS"), res.setHeader("Access-Control-Allow-Headers", "Content-Type"), req.method === "OPTIONS") {
+      res.writeHead(204), res.end();
+      return;
+    }
+    if (pathname === "/api/revert-file" && req.method === "POST") {
+      try {
+        let body = JSON.parse(await readBody2(req)), { filePath: path, isUntracked } = body;
+        if (!path || typeof path != "string") {
+          sendError2(res, 400, "Missing filePath");
+          return;
+        }
+        revertFile(path, !!isUntracked), sendJson2(res, { ok: !0 });
+      } catch (err) {
+        sendError2(res, 500, `Failed to revert file: ${err}`);
+      }
+      return;
+    }
+    if (pathname === "/api/revert-hunk" && req.method === "POST") {
+      try {
+        let body = JSON.parse(await readBody2(req)), { patch } = body;
+        if (!patch || typeof patch != "string") {
+          sendError2(res, 400, "Missing patch");
+          return;
+        }
+        revertHunk(patch), sendJson2(res, { ok: !0 });
+      } catch (err) {
+        sendError2(res, 500, `Failed to revert hunk: ${err}`);
+      }
+      return;
+    }
+    if (pathname === "/api/overview") {
+      try {
+        let staged = getStagedFiles(), unstaged = getUnstagedFiles(), untracked = getUntrackedFiles(), fileMap = /* @__PURE__ */ new Map();
+        for (let f of staged)
+          fileMap.set(f, "staged");
+        for (let f of unstaged)
+          fileMap.set(f, "modified");
+        for (let f of untracked)
+          fileMap.set(f, "added");
+        let files = Array.from(fileMap.entries()).map(([path, status]) => ({ path, status }));
+        sendJson2(res, { files });
+      } catch (err) {
+        sendError2(res, 500, `Failed to get overview: ${err}`);
+      }
+      return;
+    }
+    if (pathname === "/api/commits") {
+      let count = parseInt(url.searchParams.get("count") || "10", 10), skip = parseInt(url.searchParams.get("skip") || "0", 10), search = url.searchParams.get("search") || void 0;
+      try {
+        let commits = getRecentCommits({ count, skip, search });
+        sendJson2(res, { commits, hasMore: commits.length === count });
+      } catch (err) {
+        sendError2(res, 500, `Failed to get commits: ${err}`);
+      }
+      return;
+    }
+    if (pathname === "/api/diff-fingerprint") {
+      let ref = url.searchParams.get("ref"), stat;
+      if (ref)
+        switch (ref) {
+          case "work":
+          case "working":
+            stat = getDiffStat(["HEAD"]) + `
+` + getUntrackedFiles().join(`
+`);
+            break;
+          case "staged":
+            stat = getDiffStat(["--staged"]);
+            break;
+          case "unstaged":
+            stat = getDiffStat([]);
+            break;
+          case "untracked":
+            stat = getUntrackedFiles().join(`
+`);
+            break;
+          default:
+            stat = getDiffStat([ref]);
+            break;
+        }
+      else
+        stat = getDiffStat(diffArgs), includeUntracked && (stat += `
+` + getUntrackedFiles().join(`
+`));
+      let hash = createHash2("sha1").update(stat).digest("hex").slice(0, 12);
+      sendJson2(res, { fingerprint: hash });
+      return;
+    }
+    if (pathname === "/api/diff") {
+      let ref = url.searchParams.get("ref"), whitespace = url.searchParams.get("whitespace"), extraArgs = whitespace === "hide" ? ["-w"] : [], baseRef = ref ? resolveBaseRef(ref) : "HEAD";
+      if (ref) {
+        sendJson2(res, enrichWithLineCounts(parseDiff(resolveRef(ref, extraArgs)), baseRef));
+        return;
+      }
+      if (whitespace === "hide") {
+        sendJson2(res, enrichWithLineCounts(parseDiff(getFullDiff([...diffArgs, "-w"])), baseRef));
+        return;
+      }
+      sendJson2(res, enrichWithLineCounts(parseDiff(getFullDiff(diffArgs)), baseRef));
+      return;
+    }
+    if (pathname.startsWith("/api/file/")) {
+      let filePath2 = decodeURIComponent(pathname.slice(10)), ref = url.searchParams.get("ref") || void 0, baseRef = ref ? resolveBaseRef(ref) : "HEAD";
+      try {
+        let content = getFileContent(filePath2, baseRef);
+        sendJson2(res, { path: filePath2, content: content.split(`
+`) });
+      } catch {
+        sendError2(res, 404, `File not found: ${filePath2}`);
+      }
+      return;
+    }
+    if (pathname === "/api/info") {
+      let ref = url.searchParams.get("ref"), info = getRepoInfo(), refDescription = description || diffArgs.join(" ") || "Unstaged changes";
+      ref && (refDescription = descriptionForRef(ref)), sendJson2(res, {
+        ...info,
+        description: refDescription,
+        capabilities: { reviews: reviewsEnabled },
+        sessionId
+      });
+      return;
+    }
+    if (handleReviewRoute(req, res, pathname, url))
+      return;
+    let filePath = join4(uiDir, pathname === "/" ? "index.html" : pathname);
+    existsSync(filePath) || (filePath = join4(uiDir, "index.html")), serveStatic(res, filePath);
+  }), closeFn = () => server.close();
+  return new Promise((resolve, reject) => {
+    let retries = 0, maxRetries = 30, onError = (err) => {
+      err.code === "EADDRINUSE" && retries < maxRetries ? (retries++, server.close(), setTimeout(() => server.listen(port), 500)) : reject(err);
+    };
+    server.on("error", onError), server.on("listening", () => {
+      let addr = server.address();
+      addr && typeof addr != "string" && resolve({ port: addr.port, close: closeFn });
+    }), server.listen(port);
+  });
+}
+
+// src/agent.ts
+import pc from "picocolors";
+function requireSession() {
+  isGitRepo() || (console.error(pc.red("Error: Not a git repository")), process.exit(1));
+  let session = getCurrentSession();
+  return session || (console.error(pc.red("Error: No active review session.")), console.error(pc.dim("Start diffity first to create a session.")), process.exit(1)), session;
+}
+function resolveThreadId(shortId, sessionId) {
+  let thread = getThread(shortId);
+  return thread || (console.error(pc.red(`Error: Thread not found: ${shortId}`)), process.exit(1)), thread.sessionId !== sessionId && (console.error(pc.red(`Error: Thread ${shortId} does not belong to current session`)), process.exit(1)), thread;
+}
+function formatThreadLine(thread) {
+  let shortId = thread.id.slice(0, 8), isGeneral = thread.filePath === "__general__", statusLabel = (thread.status === "open" ? pc.yellow : thread.status === "resolved" ? pc.green : thread.status === "dismissed" ? pc.dim : pc.cyan)(`[${thread.status}]`), firstComment = thread.comments[0]?.body || "", truncated = firstComment.length > 80 ? firstComment.slice(0, 77) + "..." : firstComment;
+  if (isGeneral)
+    return `${statusLabel.padEnd(22)} ${pc.dim(shortId)}  ${pc.bold("General comment")}
+${"".padEnd(15)}${pc.dim('"')}${truncated}${pc.dim('"')}`;
+  let lineRange = thread.startLine === thread.endLine ? `${thread.startLine}` : `${thread.startLine}-${thread.endLine}`, location = `${thread.filePath}:${lineRange}`, sideLabel = thread.side === "old" ? "(old)" : "(new)";
+  return `${statusLabel.padEnd(22)} ${pc.dim(shortId)}  ${location} ${pc.dim(sideLabel)}
+${"".padEnd(15)}${pc.dim('"')}${truncated}${pc.dim('"')}`;
+}
+function registerAgentCommands(program2) {
+  let agent = program2.command("agent").description("Agent commands for interacting with review comments").addHelpText("after", `
+Examples:
+  $ diffity agent list --status open --json
+  $ diffity agent comment --file src/app.ts --line 42 --body "Missing null check"
+  $ diffity agent resolve abc123 --summary "Added null check"
+  $ diffity agent reply abc123 --body "Good catch, fixed"
+  $ diffity agent general-comment --body "Overall this looks good, just a few nits"`);
+  agent.command("list").description("List comment threads in the current session (use --json for full details)").option("--status <status>", "Filter by status (open, resolved, dismissed)").option("--json", "Output as JSON").action((opts) => {
+    let validStatuses = ["open", "resolved", "dismissed"];
+    opts.status && !validStatuses.includes(opts.status) && (console.error(pc.red(`Error: Invalid status "${opts.status}". Must be one of: ${validStatuses.join(", ")}`)), process.exit(1));
+    let session = requireSession(), threads = getThreadsForSession(session.id, opts.status);
+    if (opts.json) {
+      console.log(JSON.stringify(threads, null, 2));
+      return;
+    }
+    if (threads.length === 0) {
+      console.log(pc.dim("No threads found."));
+      return;
+    }
+    for (let thread of threads)
+      console.log(formatThreadLine(thread));
+  }), agent.command("comment").description("Create a new comment thread").requiredOption("--file <path>", "File path (relative to repo root)").requiredOption("--line <n>", "Line number (1-indexed)", parseInt).option("--end-line <n>", "End line for multi-line comments (1-indexed)", parseInt).option("--side <side>", "Which side of the diff (new or old)", "new").requiredOption("--body <text>", "Comment body").action((opts) => {
+    opts.side !== "new" && opts.side !== "old" && (console.error(pc.red(`Error: Invalid side "${opts.side}". Must be "new" or "old"`)), process.exit(1));
+    let session = requireSession(), endLine = opts.endLine ?? opts.line, thread = createThread(
+      session.id,
+      opts.file,
+      opts.side,
+      opts.line,
+      endLine,
+      opts.body,
+      { name: "Agent", type: "agent" }
+    );
+    console.log(pc.green(`Created thread ${thread.id.slice(0, 8)}`));
+  }), agent.command("resolve").description("Resolve a thread (marks as fixed)").argument("<thread-id>", "Thread ID (or 8-char prefix)").option("--summary <text>", "What was done to resolve it").action((id, opts) => {
+    let session = requireSession(), thread = resolveThreadId(id, session.id), author = opts.summary ? { name: "Agent", type: "agent" } : void 0;
+    updateThreadStatus(thread.id, "resolved", opts.summary, author), console.log(pc.green(`Resolved thread ${thread.id.slice(0, 8)}`));
+  }), agent.command("dismiss").description("Dismiss a thread (marks as won't fix)").argument("<thread-id>", "Thread ID (or 8-char prefix)").option("--reason <text>", "Why the thread is being dismissed").action((id, opts) => {
+    let session = requireSession(), thread = resolveThreadId(id, session.id), author = opts.reason ? { name: "Agent", type: "agent" } : void 0;
+    updateThreadStatus(thread.id, "dismissed", opts.reason, author), console.log(pc.green(`Dismissed thread ${thread.id.slice(0, 8)}`));
+  }), agent.command("reply").description("Reply to a comment thread").argument("<thread-id>", "Thread ID (or 8-char prefix)").requiredOption("--body <text>", "Reply body").action((id, opts) => {
+    let session = requireSession(), thread = resolveThreadId(id, session.id);
+    addReply(thread.id, opts.body, { name: "Agent", type: "agent" }), console.log(pc.green(`Replied to thread ${thread.id.slice(0, 8)}`));
+  }), agent.command("general-comment").description("Create a general comment on the entire diff (not tied to a specific file or line)").requiredOption("--body <text>", "Comment body").action((opts) => {
+    let session = requireSession(), thread = createThread(
+      session.id,
+      "__general__",
+      "new",
+      0,
+      0,
+      opts.body,
+      { name: "Agent", type: "agent" }
+    );
+    console.log(pc.green(`Created general comment ${thread.id.slice(0, 8)}`));
+  });
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url), pkg = require2("../package.json"), program = new Command();
+program.name("diffity").description("GitHub-style git diff viewer in the browser").version(pkg.version).argument("[refs...]", "Git refs to diff (e.g. HEAD~3, main, main..feature)").option("--port <port>", "Port to use", "5391").option("--no-open", "Do not open browser automatically").option("--quiet", "Minimal terminal output").option("--dark", "Open in dark mode (default: light)").option("--unified", "Open in unified view (default: split)").addHelpText("after", `
+Examples:
+  $ diffity                    Working tree changes
+  $ diffity HEAD~1             Last commit vs working tree
+  $ diffity HEAD~3             Last 3 commits vs working tree
+  $ diffity abc1234            Changes since a specific commit
+  $ diffity main..feature      Compare branches
+  $ diffity main feature       Same as main..feature
+  $ diffity v1.0.0..v2.0.0    Compare tags`).action(async (refs, opts) => {
+  isGitRepo() || (console.error(pc2.red("Error: Not a git repository")), process.exit(1));
+  let diffArgs = [], description = "";
+  if (refs.length === 1) {
+    let ref = refs[0];
+    ref.includes("..") ? (diffArgs.push(ref), description = ref) : (diffArgs.push(ref), description = `Changes from ${ref}`);
+  } else refs.length === 2 ? (diffArgs.push(`${refs[0]}..${refs[1]}`), description = `${refs[0]}..${refs[1]}`) : description = "Unstaged changes";
+  let port = parseInt(opts.port, 10), effectiveRef;
+  refs.length > 0 ? effectiveRef = refs.length === 2 ? `${refs[0]}..${refs[1]}` : refs[0] : effectiveRef = "work";
+  try {
+    let { port: actualPort, close } = await startServer({ port, diffArgs, description, effectiveRef }), urlParams = new URLSearchParams({ ref: effectiveRef });
+    opts.dark && urlParams.set("theme", "dark"), opts.unified && urlParams.set("view", "unified");
+    let url = `http://localhost:${actualPort}/?${urlParams.toString()}`;
+    opts.quiet || (console.log(""), console.log(pc2.bold("  diffity")), console.log(`  ${pc2.dim(description)}`), console.log(""), console.log(`  ${pc2.green("\u2192")} ${pc2.cyan(url)}`), console.log(`  ${pc2.dim("Press Ctrl+C to stop")}`), console.log("")), process.on("SIGINT", () => {
+      opts.quiet || console.log(pc2.dim(`
+  Shutting down...`)), close(), process.exit(0);
+    }), process.on("SIGTERM", () => {
+      close(), process.exit(0);
+    }), opts.open !== !1 && await open(url);
+  } catch (err) {
+    console.error(pc2.red(`Failed to start server: ${err}`)), process.exit(1);
+  }
+});
+program.command("prune").description("Remove all diffity data (database, sessions) for all repos").action(() => {
+  let dir = join5(homedir2(), ".diffity");
+  if (!existsSync2(dir)) {
+    console.log(pc2.dim("Nothing to prune."));
+    return;
+  }
+  rmSync(dir, { recursive: !0, force: !0 }), console.log(pc2.green("Pruned all diffity data (~/.diffity)."));
+});
+program.command("update").description("Update diffity to the latest version").action(() => {
+  try {
+    let registry = execSync3("npm view diffity version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    if (registry === pkg.version) {
+      console.log(pc2.green(`Already on the latest version (${pkg.version}).`));
+      return;
+    }
+    console.log(`${pc2.dim(`Current: ${pkg.version}`)} \u2192 ${pc2.bold(registry)}`), console.log(pc2.dim("Updating...")), execSync3("npm install -g diffity@latest", { stdio: "inherit" }), console.log(pc2.green(`Updated to ${registry}.`));
+  } catch {
+    console.error(pc2.red("Failed to update. Try running: npm install -g diffity@latest")), process.exit(1);
+  }
+});
+program.command("doctor").description("Check that diffity can run correctly").action(() => {
+  let ok = !0;
+  process.stdout.write("  git          ");
+  try {
+    let gitVersion = execSync3("git --version", { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] }).trim();
+    console.log(pc2.green(`\u2713 ${gitVersion}`));
+  } catch {
+    console.log(pc2.red("\u2717 git not found")), ok = !1;
+  }
+  process.stdout.write("  git repo     "), isGitRepo() ? console.log(pc2.green("\u2713 inside a git repository")) : console.log(pc2.yellow("- not inside a git repository")), process.stdout.write("  node         "), console.log(pc2.green(`\u2713 ${process.version}`)), process.stdout.write("  sqlite       ");
+  try {
+    require2("better-sqlite3"), console.log(pc2.green("\u2713 better-sqlite3 loaded"));
+  } catch {
+    console.log(pc2.red("\u2717 better-sqlite3 failed to load (native module issue)")), ok = !1;
+  }
+  process.stdout.write("  version      "), console.log(pc2.green(`\u2713 diffity ${pkg.version}`)), console.log(""), ok ? console.log(pc2.green("  All checks passed.")) : (console.log(pc2.red("  Some checks failed. Fix the issues above and try again.")), process.exit(1));
+});
+registerAgentCommands(program);
+program.parse();