polydiff 0.1.0

package/server/db.mjs

@@ -0,0 +1,284 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+
+const directory =
+  process.env.POLYDIFF_HOME || path.join(os.homedir(), ".polydiff");
+const file = path.join(directory, "db.json");
+const recentLimit = 10;
+
+export const defaults = {
+  theme: "system",
+  layout: "unified",
+  wrap: false,
+  wordDiff: "word-alt",
+  expansionLines: 20,
+  density: "compact",
+  scanDepth: 8,
+  scanBudget: 10000,
+  ignore: [],
+};
+const choices = {
+  theme: ["system", "light", "dark"],
+  layout: ["unified", "split"],
+  wordDiff: ["word-alt", "word", "char", "none"],
+  density: ["compact", "default", "relaxed"],
+};
+const ranges = {
+  expansionLines: [5, 200],
+  scanDepth: [1, 16],
+  scanBudget: [100, 200000],
+};
+const selections = ["changed", "all", "none", "custom"];
+
+function blank() {
+  return {
+    version: 2,
+    revision: 0,
+    settings: { ...defaults },
+    activeTab: null,
+    tabs: [],
+    recent: [],
+  };
+}
+function cleanSettings(value) {
+  const settings = { ...defaults };
+  if (!value || typeof value !== "object") return settings;
+  for (const [key, allowed] of Object.entries(choices))
+    if (allowed.includes(value[key])) settings[key] = value[key];
+  for (const [key, [low, high]] of Object.entries(ranges)) {
+    const number = Math.round(Number(value[key]));
+    if (Number.isFinite(number))
+      settings[key] = Math.min(high, Math.max(low, number));
+  }
+  if (typeof value.wrap === "boolean") settings.wrap = value.wrap;
+  if (Array.isArray(value.ignore))
+    settings.ignore = [
+      ...new Set(
+        value.ignore.filter(
+          (name) =>
+            typeof name === "string" &&
+            name.length > 0 &&
+            name.length < 64 &&
+            !/[/\\]/.test(name),
+        ),
+      ),
+    ].slice(0, 100);
+  return settings;
+}
+function cleanRepos(value) {
+  if (!value || typeof value !== "object") return {};
+  const repos = {};
+  for (const [repo, settings] of Object.entries(value)) {
+    if (!path.isAbsolute(repo) || !settings || typeof settings !== "object")
+      continue;
+    const clean = {};
+    if (typeof settings.base === "string" && settings.base)
+      clean.base = settings.base;
+    if (
+      typeof settings.target === "string" &&
+      settings.target &&
+      settings.target !== "@working"
+    )
+      clean.target = settings.target;
+    if (typeof settings.selected === "boolean")
+      clean.selected = settings.selected;
+    if (Object.keys(clean).length) repos[repo] = clean;
+  }
+  return repos;
+}
+function cleanTab(value, seen, migrating) {
+  if (!value || typeof value !== "object") return null;
+  if (typeof value.id !== "string" || !value.id || seen.has(value.id))
+    return null;
+  if (typeof value.root !== "string" || !path.isAbsolute(value.root))
+    return null;
+  seen.add(value.id);
+  const repos = cleanRepos(value.repos);
+  // Version 1 had no selection mode. A tab where every repository was ticked
+  // by hand is a custom selection; anything else followed the changes.
+  const inferred =
+    migrating &&
+    Object.values(repos).some((settings) => settings.selected !== undefined)
+      ? "custom"
+      : "changed";
+  return {
+    id: value.id,
+    root: value.root,
+    selection: selections.includes(value.selection)
+      ? value.selection
+      : inferred,
+    repos,
+  };
+}
+export function sanitize(value) {
+  if (!value || typeof value !== "object") return blank();
+  const migrating = value.version !== 2;
+  const seen = new Set();
+  const list = (input) =>
+    (Array.isArray(input) ? input : [])
+      .map((tab) => cleanTab(tab, seen, migrating))
+      .filter(Boolean);
+  const tabs = list(value.tabs);
+  const recent = list(value.recent).slice(0, recentLimit);
+  const revision =
+    Number.isInteger(value.revision) && value.revision >= 0
+      ? value.revision
+      : 0;
+  return {
+    version: 2,
+    revision,
+    settings: cleanSettings(value.settings),
+    activeTab: tabs.some((tab) => tab.id === value.activeTab)
+      ? value.activeTab
+      : (tabs[0]?.id ?? null),
+    tabs,
+    recent,
+  };
+}
+function nextId(state) {
+  const taken = new Set([...state.tabs, ...state.recent].map((tab) => tab.id));
+  const stamp = Date.now().toString(36);
+  for (let suffix = 0; ; suffix++) {
+    const id = `t${stamp}${suffix ? suffix.toString(36) : ""}`;
+    if (!taken.has(id)) return id;
+  }
+}
+function insert(state, tab, index) {
+  return {
+    ...state,
+    activeTab: tab.id,
+    tabs: [...state.tabs.slice(0, index), tab, ...state.tabs.slice(index)],
+  };
+}
+export function apply(state, command) {
+  const op = command && typeof command === "object" ? command.op : null;
+  if (op === "settings")
+    return {
+      ...state,
+      settings: cleanSettings({ ...state.settings, ...command.settings }),
+    };
+  if (op === "open") {
+    if (typeof command.root !== "string" || !path.isAbsolute(command.root))
+      throw new Error("Choose a directory.");
+    if (command.focus) {
+      const existing = state.tabs.find((tab) => tab.root === command.root);
+      if (existing) return { ...state, activeTab: existing.id };
+    }
+    const tab = {
+      id: nextId(state),
+      root: command.root,
+      selection: "changed",
+      repos: {},
+    };
+    return insert(state, tab, state.tabs.length);
+  }
+  if (op === "duplicate") {
+    const index = state.tabs.findIndex((tab) => tab.id === command.id);
+    if (index < 0) return state;
+    const source = state.tabs[index];
+    return insert(
+      state,
+      { ...source, id: nextId(state), repos: { ...source.repos } },
+      index + 1,
+    );
+  }
+  if (op === "close") {
+    const index = state.tabs.findIndex((tab) => tab.id === command.id);
+    if (index < 0) return state;
+    const tabs = state.tabs.filter((tab) => tab.id !== command.id);
+    return {
+      ...state,
+      tabs,
+      activeTab:
+        state.activeTab === command.id
+          ? (tabs[Math.min(index, tabs.length - 1)]?.id ?? null)
+          : state.activeTab,
+      recent: [state.tabs[index], ...state.recent].slice(0, recentLimit),
+    };
+  }
+  if (op === "reopen") {
+    const [closed, ...recent] = state.recent;
+    if (!closed) return state;
+    return { ...insert(state, closed, state.tabs.length), recent };
+  }
+  if (op === "activate")
+    return state.tabs.some((tab) => tab.id === command.id)
+      ? { ...state, activeTab: command.id }
+      : state;
+  if (op === "tab") {
+    const current = state.tabs.find((tab) => tab.id === command.id);
+    if (!current) return state;
+    // Repository settings merge so that a repository missing from the latest
+    // scan keeps what it was given.
+    const tab = {
+      ...current,
+      selection: selections.includes(command.selection)
+        ? command.selection
+        : current.selection,
+      repos:
+        command.repos && typeof command.repos === "object"
+          ? cleanRepos({ ...current.repos, ...command.repos })
+          : current.repos,
+    };
+    return {
+      ...state,
+      tabs: state.tabs.map((item) => (item.id === command.id ? tab : item)),
+    };
+  }
+  throw new Error(`Unknown command: ${op}`);
+}
+function trim(state) {
+  const settings = {};
+  for (const [key, value] of Object.entries(state.settings))
+    if (JSON.stringify(value) !== JSON.stringify(defaults[key]))
+      settings[key] = value;
+  return { ...state, settings };
+}
+let queue = Promise.resolve();
+async function load() {
+  let raw;
+  try {
+    raw = await readFile(file, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return blank();
+    throw error;
+  }
+  try {
+    return sanitize(JSON.parse(raw));
+  } catch {
+    await rename(file, `${file}.corrupt`).catch(() => {});
+    return blank();
+  }
+}
+export function read() {
+  return load();
+}
+async function persist(state) {
+  await mkdir(directory, { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  await writeFile(temp, `${JSON.stringify(trim(state), null, 2)}\n`);
+  await rename(temp, file);
+}
+function update(change) {
+  const next = queue.then(async () => {
+    const current = await read();
+    const state = sanitize({
+      ...change(current),
+      revision: current.revision + 1,
+    });
+    await persist(state);
+    return state;
+  });
+  queue = next.then(
+    () => {},
+    () => {},
+  );
+  return next;
+}
+export function send(command) {
+  return update((state) => apply(state, command));
+}
+export function write(value) {
+  return update(() => sanitize(value));
+}

package/server/git.mjs

@@ -0,0 +1,301 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { readdir, stat, lstat, readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+
+const exec = promisify(execFile);
+export async function git(cwd, args, allowed = [0]) {
+  try {
+    return (
+      await exec("git", ["-c", "core.quotePath=false", ...args], {
+        cwd,
+        maxBuffer: 16 * 1024 * 1024,
+        timeout: 30000,
+        env: {
+          ...process.env,
+          GIT_OPTIONAL_LOCKS: "0",
+          GIT_TERMINAL_PROMPT: "0",
+        },
+      })
+    ).stdout;
+  } catch (error) {
+    if (allowed.includes(error.code)) return error.stdout;
+    throw new Error(error.stderr?.trim() || error.message);
+  }
+}
+// Directory names that never hold a repository worth reviewing. Build output
+// names like build, dist, and target are deliberately absent: they are also
+// ordinary repository names.
+const ignored = new Set([
+  ".git",
+  "node_modules",
+  "vendor",
+  ".next",
+  ".cache",
+  ".pnpm-store",
+  ".turbo",
+  ".parcel-cache",
+  ".svelte-kit",
+  "__pycache__",
+  "site-packages",
+  "venv",
+  ".venv",
+  ".tox",
+  ".mypy_cache",
+  ".pytest_cache",
+  ".ruff_cache",
+  ".gradle",
+  ".terraform",
+  "DerivedData",
+  "Pods",
+]);
+// macOS bundles are directory trees presented as single files.
+const bundle = /\.(app|framework|bundle|xcassets|photoslibrary)$/i;
+export async function scan(
+  root,
+  { depth = 8, budget = 10000, ignore = [] } = {},
+) {
+  if (!(await stat(root)).isDirectory()) throw new Error("Choose a directory.");
+  const skip = ignore.length ? new Set([...ignored, ...ignore]) : ignored;
+  const repos = [];
+  const warnings = [];
+  let visited = 0;
+  let exhausted = false;
+  const tooDeep = [];
+  async function walk(dir, level) {
+    if (++visited > budget) {
+      exhausted = true;
+      return;
+    }
+    if (level > depth) {
+      tooDeep.push(dir);
+      return;
+    }
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch {
+      warnings.push(`Could not read ${dir}`);
+      return;
+    }
+    if (entries.some((entry) => entry.name === ".git")) {
+      try {
+        const branch =
+          (
+            await git(dir, ["symbolic-ref", "--short", "-q", "HEAD"], [0, 1])
+          ).trim() || "Detached HEAD";
+        const refs = (
+          await git(dir, [
+            "for-each-ref",
+            "--format=%(refname)",
+            "refs/heads",
+            "refs/remotes",
+          ])
+        )
+          .trim()
+          .split("\n")
+          .filter(Boolean);
+        const local = [];
+        const remote = [];
+        for (const ref of refs) {
+          if (ref.startsWith("refs/heads/"))
+            local.push(ref.slice("refs/heads/".length));
+          else if (ref.startsWith("refs/remotes/")) {
+            const name = ref.slice("refs/remotes/".length);
+            if (name.includes("/") && !name.endsWith("/HEAD"))
+              remote.push(name);
+          }
+        }
+        const remoteHead = (
+          await git(
+            dir,
+            ["symbolic-ref", "--short", "-q", "refs/remotes/origin/HEAD"],
+            [0, 1],
+          )
+        ).trim();
+        const base = [
+          remoteHead,
+          "origin/main",
+          "main",
+          "origin/master",
+          "master",
+          "HEAD",
+        ].find(
+          (ref) =>
+            ref &&
+            (ref === "HEAD" || local.includes(ref) || remote.includes(ref)),
+        );
+        repos.push({
+          path: dir,
+          name: path.relative(root, dir) || path.basename(dir),
+          branch,
+          branches: { local, remote },
+          base,
+          worktree: entries.find((entry) => entry.name === ".git").isFile(),
+        });
+      } catch (error) {
+        warnings.push(`${dir}: ${error.message}`);
+      }
+      if (
+        entries.some(
+          (entry) => entry.name === ".worktrees" && entry.isDirectory(),
+        )
+      )
+        await walk(path.join(dir, ".worktrees"), level + 1);
+      return;
+    }
+    for (const entry of entries) {
+      if (
+        entry.isDirectory() &&
+        !skip.has(entry.name) &&
+        !bundle.test(entry.name)
+      )
+        await walk(path.join(dir, entry.name), level + 1);
+      if (visited > budget) break;
+    }
+  }
+  await walk(root, 0);
+  if (exhausted)
+    warnings.push(
+      `Stopped after ${budget.toLocaleString("en-US")} directories. Some repositories may be missing. Raise the directory budget in Settings to search further.`,
+    );
+  if (tooDeep.length)
+    warnings.push(
+      `Stopped at ${depth} directory levels in ${tooDeep.length} place${
+        tooDeep.length === 1 ? "" : "s"
+      }, such as ${path.relative(root, tooDeep[0])}. Raise the search depth in Settings to look deeper.`,
+    );
+  return {
+    root,
+    repos: repos.sort((a, b) => a.name.localeCompare(b.name)),
+    warnings,
+  };
+}
+export async function diff(repo, base, target) {
+  const resolve = async (ref) =>
+    (
+      await git(repo, [
+        "rev-parse",
+        "--verify",
+        "--end-of-options",
+        `${ref}^{commit}`,
+      ])
+    ).trim();
+  const baseHash = await resolve(base);
+  const targetHash = await resolve(target === "@working" ? "HEAD" : target);
+  const mergeBase = (
+    await git(repo, ["merge-base", baseHash, targetHash])
+  ).trim();
+  const args = [
+    "diff",
+    "--no-ext-diff",
+    "--no-textconv",
+    "--no-color",
+    "--find-renames",
+    mergeBase,
+  ];
+  if (target !== "@working") args.push(targetHash);
+  args.push("--");
+  let patch = await git(repo, args);
+  const warnings = [];
+  if (target === "@working") {
+    const untracked = (
+      await git(repo, ["ls-files", "--others", "--exclude-standard", "-z"])
+    )
+      .split("\0")
+      .filter(Boolean);
+    for (const file of untracked) {
+      try {
+        const info = await lstat(path.join(repo, file));
+        if (!info.isFile() || info.size > 1024 * 1024) {
+          warnings.push(
+            `Untracked file skipped (not a regular file or exceeds 1 MB): ${file}`,
+          );
+          continue;
+        }
+        patch += await git(
+          repo,
+          [
+            "diff",
+            "--no-index",
+            "--no-ext-diff",
+            "--no-textconv",
+            "--no-color",
+            "--",
+            "/dev/null",
+            file,
+          ],
+          [0, 1],
+        );
+      } catch (error) {
+        warnings.push(`${file}: ${error.message}`);
+      }
+      if (Buffer.byteLength(patch) > 16 * 1024 * 1024)
+        throw new Error("Diff exceeds 16 MB. Choose a narrower comparison.");
+    }
+  }
+  return {
+    patch,
+    mergeBase,
+    targetRef: target === "@working" ? "@working" : targetHash,
+    warnings,
+  };
+}
+
+// Full contents are loaded only when the diff renderer expands hidden context.
+export async function fileContents(
+  repo,
+  { name, oldName = name, oldRef, newRef, expectedHash },
+) {
+  const root = await realpath(repo);
+  function validateName(value) {
+    if (
+      !value ||
+      path.isAbsolute(value) ||
+      value.split(/[\\/]/).some((part) => part === ".." || part === ".git")
+    )
+      throw new Error("Invalid file path.");
+    const resolved = path.resolve(root, value);
+    if (!resolved.startsWith(root + path.sep))
+      throw new Error("File is outside the repository.");
+    return resolved;
+  }
+  validateName(oldName);
+  const current = validateName(name);
+  if (
+    !/^[a-f0-9]{40,64}$/.test(oldRef) ||
+    (newRef !== "@working" && !/^[a-f0-9]{40,64}$/.test(newRef))
+  )
+    throw new Error("Invalid comparison revision.");
+  const oldContents = await git(root, ["show", `${oldRef}:${oldName}`]);
+  let newContents;
+  if (newRef === "@working") {
+    const resolved = await realpath(current);
+    const info = await lstat(current);
+    if (!resolved.startsWith(root + path.sep) || !info.isFile())
+      throw new Error("Cannot expand context for this file.");
+    if (info.size > 2 * 1024 * 1024)
+      throw new Error("Context expansion is limited to files under 2 MB.");
+    newContents = await readFile(current, "utf8");
+    if (expectedHash && !/^0+$/.test(expectedHash)) {
+      const hash = (
+        await git(root, ["hash-object", `--path=${name}`, "--", name])
+      ).trim();
+      if (!hash.startsWith(expectedHash))
+        throw new Error(
+          "This file changed since the diff was loaded. Refresh to expand its context.",
+        );
+    }
+  } else newContents = await git(root, ["show", `${newRef}:${name}`]);
+  if (
+    Buffer.byteLength(oldContents) > 2 * 1024 * 1024 ||
+    Buffer.byteLength(newContents) > 2 * 1024 * 1024
+  )
+    throw new Error("Context expansion is limited to files under 2 MB.");
+  if (oldContents.includes("\0") || newContents.includes("\0"))
+    throw new Error("Binary files do not have text context.");
+  return {
+    oldFile: { name: oldName, contents: oldContents },
+    newFile: { name, contents: newContents },
+  };
+}

package/server/picker.mjs

@@ -0,0 +1,113 @@
+import { spawn } from "node:child_process";
+import { stat } from "node:fs/promises";
+
+const prompt = "Choose a workspace";
+
+function run(command, args, signal) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
+    let out = "";
+    let err = "";
+    const stop = () => child.kill();
+    signal?.addEventListener("abort", stop, { once: true });
+    child.stdout.on("data", (chunk) => (out += chunk));
+    child.stderr.on("data", (chunk) => (err += chunk));
+    child.on("error", (error) =>
+      reject(
+        Object.assign(
+          new Error(
+            error.code === "ENOENT"
+              ? `${command} is not available on this system.`
+              : error.message,
+          ),
+          { missing: error.code === "ENOENT" },
+        ),
+      ),
+    );
+    child.on("close", (code) => {
+      signal?.removeEventListener("abort", stop);
+      resolve({
+        code,
+        out: out.trim(),
+        err: err.trim(),
+        aborted: !!signal?.aborted,
+      });
+    });
+  });
+}
+async function directoryOrHome(value) {
+  try {
+    if (value && (await stat(value)).isDirectory()) return value;
+  } catch {
+    // Fall through to letting the dialog choose its own starting point.
+  }
+  return "";
+}
+async function mac(start, signal) {
+  const location = await directoryOrHome(start);
+  // Without activating first the dialog opens behind the browser window.
+  const script = [
+    'tell application "System Events"',
+    "activate",
+    `POSIX path of (choose folder with prompt ${JSON.stringify(prompt)}${
+      location ? ` default location POSIX file ${JSON.stringify(location)}` : ""
+    })`,
+    "end tell",
+  ].join("\n");
+  const { code, out, err, aborted } = await run(
+    "osascript",
+    ["-e", script],
+    signal,
+  );
+  if (code === 0 && out) return { path: out.replace(/\/$/, "") };
+  if (aborted || err.includes("-128")) return { canceled: true };
+  throw new Error(err || "The folder dialog closed unexpectedly.");
+}
+async function linux(start, signal) {
+  const location = await directoryOrHome(start);
+  try {
+    const { code, out } = await run(
+      "zenity",
+      [
+        "--file-selection",
+        "--directory",
+        `--title=${prompt}`,
+        ...(location ? [`--filename=${location}/`] : []),
+      ],
+      signal,
+    );
+    if (code === 0 && out) return { path: out };
+    return { canceled: true };
+  } catch (error) {
+    if (!error.missing) throw error;
+  }
+  const { code, out } = await run(
+    "kdialog",
+    ["--title", prompt, "--getexistingdirectory", location || "."],
+    signal,
+  );
+  if (code === 0 && out) return { path: out };
+  return { canceled: true };
+}
+async function windows(start, signal) {
+  const location = await directoryOrHome(start);
+  const script = [
+    "Add-Type -AssemblyName System.Windows.Forms",
+    "$dialog = New-Object System.Windows.Forms.FolderBrowserDialog",
+    `$dialog.Description = ${JSON.stringify(prompt)}`,
+    ...(location ? [`$dialog.SelectedPath = ${JSON.stringify(location)}`] : []),
+    "if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { $dialog.SelectedPath }",
+  ].join("; ");
+  const { code, out } = await run(
+    "powershell",
+    ["-NoProfile", "-STA", "-Command", script],
+    signal,
+  );
+  if (code === 0 && out) return { path: out };
+  return { canceled: true };
+}
+export function chooseDirectory(start, signal) {
+  if (process.platform === "darwin") return mac(start, signal);
+  if (process.platform === "win32") return windows(start, signal);
+  return linux(start, signal);
+}