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

package/src/unified-diff.ts

@@ -0,0 +1,71 @@
+export interface DiffHunk {
+  file: string;
+  oldStart: number;
+  oldLines: number;
+  newStart: number;
+  newLines: number;
+  lines: DiffHunkLine[];
+}
+
+export interface DiffHunkLine {
+  kind: "context" | "add" | "remove";
+  oldLine: number | null;
+  newLine: number | null;
+  text: string;
+}
+
+const HUNK_HEADER =
+  /^@@ -(?<oldStart>\d+)(?:,(?<oldLines>\d+))? \+(?<newStart>\d+)(?:,(?<newLines>\d+))? @@/;
+
+export function parseUnifiedPatch(
+  file: string,
+  patch: string | null | undefined,
+): DiffHunk[] {
+  if (!patch) return [];
+
+  const hunks: DiffHunk[] = [];
+  let current: DiffHunk | null = null;
+  let oldLine = 0;
+  let newLine = 0;
+
+  for (const row of patch.split(/\r?\n/)) {
+    const header = HUNK_HEADER.exec(row);
+
+    if (header?.groups) {
+      current = {
+        file,
+        oldStart: Number(header.groups.oldStart),
+        oldLines: Number(header.groups.oldLines ?? "1"),
+        newStart: Number(header.groups.newStart),
+        newLines: Number(header.groups.newLines ?? "1"),
+        lines: [],
+      };
+      oldLine = current.oldStart;
+      newLine = current.newStart;
+      hunks.push(current);
+      continue;
+    }
+
+    if (!current || row.startsWith("\")) continue;
+
+    const marker = row[0];
+    const text = row.slice(1);
+    let line: DiffHunkLine | null = null;
+
+    if (marker === " ") {
+      line = { kind: "context", oldLine, newLine, text };
+      oldLine += 1;
+      newLine += 1;
+    } else if (marker === "+") {
+      line = { kind: "add", oldLine: null, newLine, text };
+      newLine += 1;
+    } else if (marker === "-") {
+      line = { kind: "remove", oldLine, newLine: null, text };
+      oldLine += 1;
+    }
+
+    if (line) current.lines.push(line);
+  }
+
+  return hunks;
+}

package/src/viewed-coverage.ts

@@ -0,0 +1,259 @@
+import { structuralChangeCounts } from "@dev.fast/review-protocol";
+import { z } from "zod";
+
+import type { FileLineRange } from "./source.js";
+
+/** Zero-based, half-open intervals; always normalized at the storage boundary. */
+export type LineInterval = [number, number];
+
+export interface Coverage {
+  base: LineInterval[];
+  head: LineInterval[];
+}
+
+export const coverageSchema = z.object({
+  base: z.array(
+    z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()]),
+  ),
+  head: z.array(
+    z.tuple([z.number().int().nonnegative(), z.number().int().nonnegative()]),
+  ),
+});
+
+export interface ChangeCounts {
+  additions: number;
+  deletions: number;
+}
+
+/**
+ * Changed lines that diffr folds by default count as done, the way the
+ * reader's viewed marks do. `folded` is how many of the scope's lines are
+ * done only because they are folded; `remaining` excludes them.
+ * "folded" is the state of a scope with nothing left to read and nothing the
+ * reader marked: all of it starts folded.
+ */
+export interface CoverageProgress {
+  state: "unread" | "partial" | "viewed" | "folded";
+  total: ChangeCounts;
+  remaining: ChangeCounts;
+  folded: ChangeCounts;
+}
+
+export interface CoverageFile {
+  path: string;
+  previousPath?: string;
+  fingerprint: string;
+  changed: Coverage;
+  /** The changed lines diffr folds by default: every changed line of a file
+   * it hides, or those under a region that starts collapsed. Absent without
+   * structural data, where every changed line is left to read. */
+  folded?: Coverage;
+  viewed: Coverage;
+}
+
+export const emptyCoverage = (): Coverage => ({ base: [], head: [] });
+
+export function unionIntervals(
+  ranges: readonly LineInterval[],
+): LineInterval[] {
+  const result: LineInterval[] = [];
+
+  for (const [start, end] of [...ranges].sort((a, b) => a[0] - b[0])) {
+    if (end <= start) continue;
+    const last = result.at(-1);
+
+    if (last && start <= last[1]) last[1] = Math.max(last[1], end);
+    else result.push([start, end]);
+  }
+
+  return result;
+}
+
+export function intersectIntervals(
+  left: readonly LineInterval[],
+  right: readonly LineInterval[],
+): LineInterval[] {
+  const result: LineInterval[] = [];
+
+  const a = unionIntervals(left),
+    b = unionIntervals(right);
+
+  let i = 0,
+    j = 0;
+
+  while (i < a.length && j < b.length) {
+    const start = Math.max(a[i][0], b[j][0]),
+      end = Math.min(a[i][1], b[j][1]);
+
+    if (start < end) result.push([start, end]);
+
+    if (a[i][1] < b[j][1]) i++;
+    else j++;
+  }
+
+  return result;
+}
+
+export function subtractIntervals(
+  left: readonly LineInterval[],
+  right: readonly LineInterval[],
+): LineInterval[] {
+  const result: LineInterval[] = [];
+  const removed = unionIntervals(right);
+
+  for (const [start, end] of unionIntervals(left)) {
+    let cursor = start;
+
+    for (const [from, to] of removed) {
+      if (to <= cursor) continue;
+
+      if (from >= end) break;
+
+      if (from > cursor) result.push([cursor, from]);
+      cursor = Math.min(end, Math.max(cursor, to));
+    }
+
+    if (cursor < end) result.push([cursor, end]);
+  }
+
+  return result;
+}
+
+export function updateCoverage(
+  current: Coverage,
+  scope: Coverage,
+  viewed: boolean,
+): Coverage {
+  const apply = (side: "base" | "head") =>
+    viewed
+      ? unionIntervals([...current[side], ...scope[side]])
+      : subtractIntervals(current[side], scope[side]);
+
+  return { base: apply("base"), head: apply("head") };
+}
+
+export function scopedCoverage(
+  file: CoverageFile,
+  sources?: readonly FileLineRange[],
+): Coverage {
+  if (!sources) return file.changed;
+
+  const side = (side: "base" | "head") =>
+    intersectIntervals(
+      file.changed[side],
+      sources.flatMap((source): LineInterval[] =>
+        source.side === side &&
+        source.file ===
+          (side === "base" ? (file.previousPath ?? file.path) : file.path)
+          ? [[source.fromLine - 1, source.toLine]]
+          : [],
+      ),
+    );
+
+  return { base: side("base"), head: side("head") };
+}
+
+export function coverageProgress(
+  files: readonly CoverageFile[],
+  sources?: readonly FileLineRange[],
+): CoverageProgress {
+  const total = { additions: 0, deletions: 0 },
+    remaining = { additions: 0, deletions: 0 },
+    folded = { additions: 0, deletions: 0 };
+
+  for (const file of files) {
+    const scope = scopedCoverage(file, sources);
+    const counts = structuralChangeCounts(scope);
+
+    const side = (side: "base" | "head") => {
+      const unviewed = subtractIntervals(scope[side], file.viewed[side]);
+
+      return {
+        unread: subtractIntervals(unviewed, file.folded?.[side] ?? []),
+        folded: intersectIntervals(unviewed, file.folded?.[side] ?? []),
+      };
+    };
+
+    const base = side("base"),
+      head = side("head");
+
+    const unread = structuralChangeCounts({
+      base: base.unread,
+      head: head.unread,
+    });
+
+    const foldedCounts = structuralChangeCounts({
+      base: base.folded,
+      head: head.folded,
+    });
+
+    total.additions += counts.added;
+    total.deletions += counts.removed;
+    remaining.additions += unread.added;
+    remaining.deletions += unread.removed;
+    folded.additions += foldedCounts.added;
+    folded.deletions += foldedCounts.removed;
+  }
+
+  return {
+    total,
+    remaining,
+    folded,
+    state: progressState(total, remaining, folded),
+  };
+}
+
+/** Progress over several comparisons at once: the sums, and the same state
+ * rule as one. */
+export function mergeCoverageProgress(
+  parts: readonly CoverageProgress[],
+): CoverageProgress {
+  const total = { additions: 0, deletions: 0 },
+    remaining = { additions: 0, deletions: 0 },
+    folded = { additions: 0, deletions: 0 };
+
+  for (const part of parts) {
+    total.additions += part.total.additions;
+    total.deletions += part.total.deletions;
+    remaining.additions += part.remaining.additions;
+    remaining.deletions += part.remaining.deletions;
+    folded.additions += part.folded.additions;
+    folded.deletions += part.folded.deletions;
+  }
+
+  return {
+    total,
+    remaining,
+    folded,
+    state: progressState(total, remaining, folded),
+  };
+}
+
+/** Done lines are the viewed and the folded ones; the state names which. */
+function progressState(
+  total: ChangeCounts,
+  remaining: ChangeCounts,
+  folded: ChangeCounts,
+): CoverageProgress["state"] {
+  const size = total.additions + total.deletions,
+    unread = remaining.additions + remaining.deletions,
+    viewed = size - unread - folded.additions - folded.deletions;
+
+  if (size > 0 && unread === 0) return viewed > 0 ? "viewed" : "folded";
+
+  return viewed > 0 ? "partial" : "unread";
+}
+
+export function coverageSources(
+  file: CoverageFile,
+  coverage = file.viewed,
+): FileLineRange[] {
+  return (["base", "head"] as const).flatMap((side) =>
+    coverage[side].map(([start, end]) => ({
+      side,
+      file: side === "base" ? (file.previousPath ?? file.path) : file.path,
+      fromLine: start + 1,
+      toLine: end,
+    })),
+  );
+}

package/src/windows-cli.ts

@@ -0,0 +1,125 @@
+import { execFile } from "node:child_process";
+import path from "node:path";
+import { promisify } from "node:util";
+
+const execFileAsync = promisify(execFile);
+
+/** cmd expands percent signs even inside quotes; delayed expansion stays off. */
+function batchPath(value: string): string {
+  if (/["\r\n\0]/.test(value)) throw new Error("Invalid Windows command path");
+
+  return value.replaceAll("%", "%%");
+}
+
+export function windowsCliShim(
+  cliPath: string,
+  runtimePath: string,
+  devHome?: string,
+): string {
+  const lines = [
+    "@echo off",
+    "rem Managed by Whiteboard Desktop. Do not edit.",
+    "setlocal DisableDelayedExpansion",
+    'set "ELECTRON_RUN_AS_NODE=1"',
+  ];
+
+  if (devHome)
+    lines.push(
+      `if not defined DEV_REVIEW_HOME set "DEV_REVIEW_HOME=${batchPath(devHome)}"`,
+    );
+  lines.push(
+    `"${batchPath(runtimePath)}" "${batchPath(cliPath)}" %*`,
+    "exit /b %errorlevel%",
+    "",
+  );
+
+  return lines.join("\r\n");
+}
+
+/** Preserve the unexpanded user PATH, including entries such as %USERPROFILE%. */
+export async function updateWindowsUserPath(
+  directory: string,
+  remove = false,
+): Promise<void> {
+  const script = `
+$ErrorActionPreference = 'Stop'
+$key = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Environment')
+$state = [Microsoft.Win32.Registry]::CurrentUser.CreateSubKey('Software\\dev.fast\\Whiteboard\\CLI')
+try {
+  $old = [string]$key.GetValue('Path', '', [Microsoft.Win32.RegistryValueOptions]::DoNotExpandEnvironmentNames)
+  $dir = $env:WHITEBOARD_COMMAND_DIRECTORY
+  $entries = @($old.Split(';'))
+  $matches = @($entries | Where-Object { [Environment]::ExpandEnvironmentVariables($_).TrimEnd('\\') -ieq $dir.TrimEnd('\\') })
+  if ($env:WHITEBOARD_REMOVE_COMMAND_PATH -eq '1') {
+    if ([string]$state.GetValue('Path', '') -ine $dir) { return }
+    $entries = @($entries | Where-Object { [Environment]::ExpandEnvironmentVariables($_).TrimEnd('\\') -ine $dir.TrimEnd('\\') })
+    $key.SetValue('Path', ($entries -join ';'), [Microsoft.Win32.RegistryValueKind]::ExpandString)
+    $state.DeleteValue('Path', $false)
+  } else {
+    if ($matches.Count -gt 0) { return }
+    $state.SetValue('Path', $dir)
+    $value = if ($old) { $dir + ';' + $old } else { $dir }
+    $key.SetValue('Path', $value, [Microsoft.Win32.RegistryValueKind]::ExpandString)
+  }
+} finally { $state.Dispose(); $key.Dispose() }
+Add-Type -Namespace Whiteboard -Name EnvironmentChange -MemberDefinition '[System.Runtime.InteropServices.DllImport("user32.dll", CharSet=System.Runtime.InteropServices.CharSet.Unicode)] public static extern System.IntPtr SendMessageTimeout(System.IntPtr h, uint m, System.UIntPtr w, string l, uint f, uint t, out System.UIntPtr r);'
+$result = [UIntPtr]::Zero
+[void][Whiteboard.EnvironmentChange]::SendMessageTimeout([IntPtr]0xffff, 0x1a, [UIntPtr]::Zero, 'Environment', 2, 5000, [ref]$result)
+`;
+
+  await execFileAsync(
+    "powershell.exe",
+    [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64"),
+    ],
+    {
+      windowsHide: true,
+      env: {
+        ...process.env,
+        WHITEBOARD_COMMAND_DIRECTORY: directory,
+        WHITEBOARD_REMOVE_COMMAND_PATH: remove ? "1" : "0",
+      },
+    },
+  );
+}
+
+export const WINDOWS_MACHINE_ENVIRONMENT_KEY =
+  "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment";
+
+/**
+ * A running process keeps the PATH it started with, so the saved user PATH is
+ * what tells whether new terminals will find the command.
+ */
+export async function windowsUserPathContains(
+  directory: string,
+  key = "HKCU\\Environment",
+): Promise<boolean> {
+  let stdout: string;
+
+  try {
+    ({ stdout } = await execFileAsync("reg.exe", ["query", key, "/v", "Path"], {
+      windowsHide: true,
+    }));
+  } catch {
+    return false;
+  }
+
+  const saved = stdout.match(/^\s*Path\s+REG_\w+\s*(.*)$/im)?.[1] ?? "";
+  const target = path.win32.resolve(directory).toLowerCase();
+
+  return saved.split(";").some((entry) => {
+    const expanded = entry
+      .trim()
+      .replace(/%([^%]+)%/g, (whole, name) => process.env[name] ?? whole);
+
+    return (
+      expanded.length > 0 &&
+      path.win32.resolve(expanded).toLowerCase() === target
+    );
+  });
+}