@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/src/review-api/worktree-source.ts

@@ -0,0 +1,170 @@
+import { execFile } from "node:child_process";
+import { createHash } from "node:crypto";
+import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { promisify } from "node:util";
+
+import { type LocalVcs, gitCommonDir } from "@dev.fast/local-vcs";
+import { isMissingFileError } from "@review/fs-utils.js";
+
+import { checkoutFs } from "./checkout-fs.js";
+import { ReviewInputError } from "./document.js";
+
+const { lstat, readFile, readlink, realpath } = checkoutFs;
+
+const exec = promisify(execFile);
+
+export const EMPTY_SOURCE = "empty-worktree-baseline";
+
+/** Never follow a working-copy link outside the selected checkout. */
+export async function localSourcePath(
+  root: string,
+  file: string,
+): Promise<string> {
+  const canonicalRoot = await realpath(root);
+  const candidate = await realpath(resolve(canonicalRoot, file));
+  const child = relative(canonicalRoot, candidate);
+
+  if (
+    !child ||
+    isAbsolute(child) ||
+    child === ".." ||
+    child.startsWith(`..${sep}`)
+  )
+    throw new ReviewInputError("Source symlink leaves the selected worktree.");
+  const stat = await lstat(candidate);
+
+  if (!stat.isFile())
+    throw new ReviewInputError("Source is not a regular file.");
+
+  return candidate;
+}
+
+/** List the live checkout's tracked files. jj tracks new files itself; Git's untracked files are left out. */
+export async function workingFiles(vcs: LocalVcs): Promise<string[]> {
+  const gitDirectory =
+    vcs.kind === "jj" ? await gitCommonDir(vcs.rootPath) : undefined;
+
+  if (vcs.kind === "jj" && !gitDirectory)
+    throw new ReviewInputError(
+      "Working source requires a Git-backed jj repository.",
+    );
+
+  const { stdout } = await exec(
+    "git",
+    [
+      "-C",
+      vcs.rootPath,
+      ...(gitDirectory
+        ? ["--git-dir", gitDirectory, "--work-tree", vcs.rootPath]
+        : []),
+      "ls-files",
+      "-z",
+      ...(vcs.kind === "git"
+        ? ["--cached"]
+        : ["--others", "--exclude-standard", "--exclude=.jj/"]),
+    ],
+    { maxBuffer: 32 * 1024 * 1024 },
+  );
+
+  const paths = [
+    ...new Set([
+      ...stdout.split("\0").filter(Boolean),
+      ...(vcs.kind === "jj" ? await vcs.listTrackedFiles() : []),
+    ]),
+  ].sort();
+
+  const present = await Promise.all(
+    paths.map(async (file) => {
+      try {
+        await lstat(resolve(vcs.rootPath, file));
+
+        return file;
+      } catch (error) {
+        if (isMissingFileError(error)) return undefined;
+        throw error;
+      }
+    }),
+  );
+
+  return present.filter((file): file is string => file !== undefined);
+}
+
+/**
+ * Count Git's untracked, non-ignored files, which working tree reviews leave
+ * out. Undefined for jj, which tracks new files itself, or when the listing
+ * is too large to read.
+ */
+export async function untrackedFileCount(
+  vcs: LocalVcs,
+): Promise<number | undefined> {
+  if (vcs.kind !== "git") return undefined;
+
+  try {
+    const { stdout } = await exec(
+      "git",
+      [
+        "-C",
+        vcs.rootPath,
+        "ls-files",
+        "-z",
+        "--others",
+        "--exclude-standard",
+        "--exclude=.jj/",
+      ],
+      { maxBuffer: 32 * 1024 * 1024 },
+    );
+
+    return stdout.split("\0").filter(Boolean).length;
+  } catch {
+    return undefined;
+  }
+}
+
+/** A refresh token, not stored source: all reads still use the checkout. */
+export async function inspectWorktree(repositoryId: string, vcs: LocalVcs) {
+  const commit =
+    (await vcs.resolveRevision(vcs.kind === "jj" ? "@" : "HEAD"))?.commit ??
+    EMPTY_SOURCE;
+
+  const hash = createHash("sha256").update(`${repositoryId}\0${commit}`);
+
+  for (const file of await workingFiles(vcs)) {
+    try {
+      const info = await lstat(resolve(vcs.rootPath, file), { bigint: true });
+      hash.update(
+        `\0${file}\0${info.ino}:${info.size}:${info.mode}:${info.mtimeNs}:${info.ctimeNs}`,
+      );
+    } catch (error) {
+      if (!isMissingFileError(error)) throw error;
+    }
+  }
+
+  return { revision: hash.digest("hex"), commit };
+}
+
+export async function readWorkingFile(
+  root: string,
+  file: string,
+): Promise<string | null> {
+  try {
+    const candidate = resolve(root, file);
+
+    // Match Git's representation of tracked links, never read their target bytes.
+    const parent = relative(
+      await realpath(root),
+      await realpath(dirname(candidate)),
+    );
+
+    if (isAbsolute(parent) || parent === ".." || parent.startsWith(`..${sep}`))
+      throw new ReviewInputError(
+        "Source symlink leaves the selected worktree.",
+      );
+
+    if ((await lstat(candidate)).isSymbolicLink()) return readlink(candidate);
+
+    return await readFile(await localSourcePath(root, file), "utf8");
+  } catch (error) {
+    if (isMissingFileError(error)) return null;
+    throw error;
+  }
+}

package/src/review-api/worktree-structural.integration.ts

@@ -0,0 +1,320 @@
+import { execFileSync } from "node:child_process";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { formatAnchor, selectionKey } from "@review/lens-selection";
+import { expect, it } from "vitest";
+
+import { createReviewApi } from "./http";
+import { openLocalReviewStore } from "./local-data";
+
+it.each([
+  { linked: false, explicitBase: false },
+  { linked: true, explicitBase: false },
+  { linked: true, explicitBase: true },
+])(
+  "resolves saved edits and refreshes cached peeks: %j",
+  async ({ linked, explicitBase }) => {
+    const root = mkdtempSync(path.join(tmpdir(), "worktree-structural-"));
+    let repository = path.join(root, "repository");
+    mkdirSync(repository);
+
+    const git = (...args: string[]) =>
+      execFileSync("git", ["-C", repository, ...args], {
+        encoding: "utf8",
+      }).trim();
+
+    git("init", "-q", "-b", "main");
+    writeFileSync(
+      path.join(repository, "value.ts"),
+      "export const value = 1;\n",
+    );
+    git("add", "value.ts");
+    git(
+      "-c",
+      "user.name=Test",
+      "-c",
+      "user.email=test@example.invalid",
+      "commit",
+      "-qm",
+      "Base",
+    );
+    const base = git("rev-parse", "HEAD");
+
+    if (explicitBase) {
+      writeFileSync(
+        path.join(repository, "value.ts"),
+        "export const value = 10;\n",
+      );
+      git(
+        "-c",
+        "user.name=Test",
+        "-c",
+        "user.email=test@example.invalid",
+        "commit",
+        "-am",
+        "Head",
+      );
+    }
+
+    if (linked) {
+      const checkout = path.join(root, "linked checkout");
+      git("worktree", "add", "-qb", "live", checkout);
+      repository = checkout;
+    }
+
+    const local = openLocalReviewStore(path.join(root, "reviews.db"));
+
+    const selection = {
+      file: "value.ts",
+      start: { side: "head" as const, line: 1 },
+      end: { side: "head" as const, line: 1 },
+    };
+
+    const source = formatAnchor(selection);
+
+    try {
+      const { id } = await local.data.register(repository);
+      writeFileSync(
+        path.join(repository, "value.ts"),
+        "export const value = 2;\n",
+      );
+      git("add", "value.ts");
+
+      const { reviewId } = await local.store.execute({
+        operation: {
+          type: "create",
+          title: "Live",
+          target: {
+            kind: "worktree",
+            repositoryId: id,
+            base: explicitBase ? base : undefined,
+          },
+        },
+      });
+
+      await local.store.execute({
+        operation: {
+          type: "edit",
+          reviewId,
+          edit: { type: "insert", content: { type: "code_peek", source } },
+        },
+      });
+      const app = createReviewApi(local.store, local.data);
+      const index = git("diff", "--cached");
+      const worktrees = git("worktree", "list", "--porcelain");
+      let revision: string | undefined;
+
+      for (const value of [2, 333]) {
+        writeFileSync(
+          path.join(repository, "value.ts"),
+          `export const value = ${value};\n`,
+        );
+        await local.store.refreshWorktrees();
+        const snapshot = local.store.read(reviewId);
+        expect(snapshot.pins!.base).toBe(base);
+        expect(snapshot.pins!.head).toBe(
+          explicitBase ? git("rev-parse", "HEAD") : base,
+        );
+        expect(snapshot.pins!.worktreeRevision).not.toBe(revision);
+        revision = snapshot.pins!.worktreeRevision;
+
+        const response = await app.request(
+          `/${reviewId}/structural-diff?file=value.ts`,
+        );
+
+        expect(response.status).toBe(200);
+
+        const events = (await response.text())
+          .trim()
+          .split("\n")
+          .map((line) => JSON.parse(line));
+
+        expect(events.find((event) => event.type === "file")).toMatchObject({
+          diff: {
+            lhs: { text: "export const value = 1;\n" },
+            rhs: { text: `export const value = ${value};\n` },
+          },
+        });
+
+        const progress = await (
+          await app.request(`/${reviewId}/progress?mode=structural`)
+        ).json();
+
+        expect(progress.unavailableSelections).toEqual({});
+        expect(
+          progress.resolvedSelections[selectionKey(selection)],
+        ).toContainEqual(
+          expect.objectContaining({
+            file: "value.ts",
+            side: "head",
+            fromLine: 1,
+            toLine: 1,
+          }),
+        );
+        expect(progress.files).toHaveLength(1);
+      }
+
+      expect(git("diff", "--cached")).toBe(index);
+      expect(git("worktree", "list", "--porcelain")).toBe(worktrees);
+    } finally {
+      await local.data.close();
+      await local.store.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  },
+  30_000,
+);
+
+it("streams added, deleted, renamed and binary working files and respects path filtering", async () => {
+  const root = mkdtempSync(path.join(tmpdir(), "worktree-files-"));
+  const repository = path.join(root, "repository");
+  mkdirSync(repository);
+
+  const git = (...args: string[]) =>
+    execFileSync("git", ["-C", repository, ...args], {
+      encoding: "utf8",
+    }).trim();
+
+  git("init", "-q", "-b", "main");
+  writeFileSync(
+    path.join(repository, "gone.ts"),
+    "export const gone = true;\n",
+  );
+  writeFileSync(
+    path.join(repository, "old name.ts"),
+    "export const renamed = true;\n",
+  );
+  writeFileSync(path.join(repository, "binary.bin"), Buffer.from([0, 1, 2, 3]));
+  git("add", ".");
+  git(
+    "-c",
+    "user.name=Test",
+    "-c",
+    "user.email=test@example.invalid",
+    "commit",
+    "-qm",
+    "Base",
+  );
+  git("mv", "old name.ts", "new name.ts");
+  git("rm", "gone.ts");
+  writeFileSync(
+    path.join(repository, "added file.ts"),
+    "export const added = 1;\n",
+  );
+  git("add", "added file.ts");
+  writeFileSync(path.join(repository, "binary.bin"), Buffer.from([0, 4, 5, 6]));
+  const index = git("diff", "--cached");
+  const local = openLocalReviewStore(path.join(root, "reviews.db"));
+
+  try {
+    const { id } = await local.data.register(repository);
+
+    const { reviewId } = await local.store.execute({
+      operation: {
+        type: "create",
+        title: "Changed files",
+        target: { kind: "worktree", repositoryId: id },
+      },
+    });
+
+    const app = createReviewApi(local.store, local.data);
+
+    const read = async (query = "") => {
+      const response = await app.request(
+        `/${reviewId}/structural-diff${query}`,
+      );
+
+      expect(response.status).toBe(200);
+
+      return (await response.text())
+        .trim()
+        .split("\n")
+        .map((line) => JSON.parse(line));
+    };
+
+    const events = await read();
+    expect(events.at(-1)).toMatchObject({ type: "complete", failed: 0 });
+    expect(events[0].files).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          status: "added",
+          file: expect.objectContaining({
+            rhs: expect.objectContaining({ path: "added file.ts" }),
+          }),
+        }),
+        expect.objectContaining({
+          status: "deleted",
+          file: expect.objectContaining({
+            lhs: expect.objectContaining({ path: "gone.ts" }),
+          }),
+        }),
+        expect.objectContaining({
+          status: "renamed",
+          file: expect.objectContaining({
+            lhs: expect.objectContaining({ path: "old name.ts" }),
+            rhs: expect.objectContaining({ path: "new name.ts" }),
+          }),
+        }),
+      ]),
+    );
+    expect(
+      events.find(
+        (event) =>
+          event.type === "file" && event.file.rhs?.path === "binary.bin",
+      ).diff.type,
+    ).toBe("binary");
+    const filtered = await read("?file=added%20file.ts");
+    expect(filtered.filter((event) => event.type === "file")).toHaveLength(1);
+    expect(filtered.find((event) => event.type === "file")).toMatchObject({
+      diff: { rhs: { text: "export const added = 1;\n" } },
+    });
+    expect(git("diff", "--cached")).toBe(index);
+  } finally {
+    await local.data.close();
+    await local.store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+}, 30_000);
+
+it("compares a staged file in an unborn repository with empty source", async () => {
+  const root = mkdtempSync(path.join(tmpdir(), "worktree-unborn-"));
+  const repository = path.join(root, "repository");
+  mkdirSync(repository);
+  execFileSync("git", ["-C", repository, "init", "-q", "-b", "main"]);
+  writeFileSync(path.join(repository, "first.ts"), "export const first = 1;\n");
+  execFileSync("git", ["-C", repository, "add", "first.ts"]);
+  const local = openLocalReviewStore(path.join(root, "reviews.db"));
+
+  try {
+    const { id } = await local.data.register(repository);
+
+    const { reviewId } = await local.store.execute({
+      operation: {
+        type: "create",
+        title: "Unborn",
+        target: { kind: "worktree", repositoryId: id },
+      },
+    });
+
+    const response = await createReviewApi(local.store, local.data).request(
+      `/${reviewId}/structural-diff`,
+    );
+
+    const events = (await response.text())
+      .trim()
+      .split("\n")
+      .map((line) => JSON.parse(line));
+
+    expect(events.at(-1)).toMatchObject({ type: "complete", failed: 0 });
+    expect(events.find((event) => event.type === "file")).toMatchObject({
+      file: { rhs: { path: "first.ts" } },
+      diff: { rhs: { text: "export const first = 1;\n" } },
+    });
+  } finally {
+    await local.data.close();
+    await local.store.close();
+    rmSync(root, { recursive: true, force: true });
+  }
+}, 30_000);