@dev.fast/whiteboard 0.2.1-preview.20261006.99 → 0.2.1-preview.20261007.101

package/src/review-api/store.ts

@@ -1237,11 +1237,6 @@ export class ReviewStore {
         ...(applied?.children && { children: applied.children }),
       };
 
-      if (snapshot.staleSources?.length)
-        warnings.push(
-          "Some authored source ranges changed. Update their references before presenting this review.",
-        );
-
       if (warnings.length) result.warnings = warnings;
 
       this.commitCommand(

package/src/server/desktop-server.ts

@@ -57,12 +57,12 @@ import { z } from "zod";
 import { aliasInstallationToAccount } from "./account-alias";
 import { CrashReportRequestSchema, reportCrashDump } from "./crash-report";
 import {
+  migrateDiffrConfig,
   readDiffrConfig,
   saveDiffrSummarizer,
   setDiffrConfigValue,
   testDiffrSummarizer,
 } from "./diffr-config";
-import { installFullDiffr } from "./diffr-languages.js";
 import {
   GlobalReviewDesktopVerbRelay,
   type ReviewDesktopVerbRelay,
@@ -397,18 +397,6 @@ export function createGlobalReviewServer(
 
     return serverJson(200, { ok: true });
   });
-  app.post("/diffr-languages/install", async () => {
-    try {
-      await installFullDiffr();
-      invalidateStructuralComparisons();
-
-      return serverJson(200, { installed: true });
-    } catch (error) {
-      return serverJson(503, {
-        error: error instanceof Error ? error.message : String(error),
-      });
-    }
-  });
 
   app.get("/diffr-config", async () =>
     serverJson(200, await readDiffrConfig()),
@@ -580,6 +568,7 @@ export function createGlobalReviewServer(
       return urlForBoundPort();
     },
     listen: async () => {
+      await migrateDiffrConfig();
       scratchpadEnabled = await readScratchpadEnabled();
       boundPort = await listen(httpServer, input.port);
       discovery.url = urlForBoundPort();

package/src/server/diffr-config.ts

@@ -15,6 +15,7 @@ import {
   type ReviewDiffrConfig,
   type ReviewDiffrProvider,
   type ReviewDiffrSummarizerInput,
+  type StructuralRegion,
   decodeStructuralDiffEvent,
   reviewDiffrSummarizerInputSchema,
 } from "@dev.fast/review-protocol";
@@ -36,29 +37,91 @@ function serialized<T>(operation: () => Promise<T>): Promise<T> {
   return next;
 }
 
+type DiffrArguments =
+  | { command: "schema" }
+  | { command: "show"; reveal: boolean }
+  | { command: "set"; patch: JsonObject }
+  | { command: "migrate" }
+  | { command: "diff"; before: string; after: string };
+
+function diffrArgv(args: DiffrArguments): string[] {
+  switch (args.command) {
+    case "schema":
+      return ["config", "schema"];
+    case "show":
+      return ["config", "show", "--json", ...(args.reveal ? ["--reveal"] : [])];
+    case "set":
+      return ["config", "set", "--stdin", "--json"];
+    case "migrate":
+      return ["config", "migrate", "--json"];
+    case "diff":
+      return [
+        "--no-index",
+        "--format",
+        "ndjson",
+        "--",
+        args.before,
+        args.after,
+      ];
+  }
+}
+
 async function diffr(
-  args: string[],
+  args: DiffrArguments,
   rootPath?: string,
   options: { signal?: AbortSignal; env?: NodeJS.ProcessEnv } = {},
 ): Promise<string> {
+  const executable = diffrExecutable();
+
   try {
-    const { stdout } = await execFileAsync(diffrExecutable(), args, {
+    const operation = execFileAsync(executable, diffrArgv(args), {
       cwd: rootPath,
       maxBuffer: 16 * 1024 * 1024,
       signal: options.signal ?? AbortSignal.timeout(30_000),
       env: options.env ?? process.env,
     });
 
+    if (args.command === "set")
+      operation.child.stdin?.end(JSON.stringify(args.patch));
+    const { stdout } = await operation;
+
     return stdout;
   } catch (error) {
-    // SAFETY: execFile rejects with an Error carrying its exit or spawn code.
+    // SAFETY: execFile adds the exit or spawn code and stdout to its Error.
     // Do not forward its message: it includes command arguments.
-    const failure = error as NodeJS.ErrnoException;
+    const failure = error as NodeJS.ErrnoException & { stdout?: string };
 
     if (failure.code === "ENOENT") throw diffrMissingError();
 
     if (failure.name === "AbortError")
       throw new Error("diffr timed out or was cancelled.");
+
+    if (
+      (args.command === "set" || args.command === "migrate") &&
+      failure.stdout
+    ) {
+      let details: JsonValue | undefined;
+
+      try {
+        details = parseJsonText(failure.stdout);
+      } catch {
+        /* Do not echo raw output in parse errors. */
+      }
+
+      if (
+        isJsonObject(details) &&
+        isJsonObject(details.error) &&
+        isStringValue(details.error.message)
+      ) {
+        const { message, repair_prompt: prompt } = details.error;
+        throw new Error(
+          isStringValue(prompt)
+            ? `${message}\n\nCopy this as a prompt to your coding agent:\n${prompt}`
+            : message,
+        );
+      }
+    }
+
     throw new Error(
       "diffr could not complete the operation. Check its configuration and credentials.",
     );
@@ -70,13 +133,7 @@ async function values(
   reveal = false,
   signal?: AbortSignal,
 ): Promise<JsonObject> {
-  return json(
-    await diffr(
-      ["config", "show", "--json", ...(reveal ? ["--reveal"] : [])],
-      rootPath,
-      { signal },
-    ),
-  );
+  return json(await diffr({ command: "show", reveal }, rootPath, { signal }));
 }
 
 function json(output: string): JsonObject {
@@ -100,7 +157,7 @@ function valueAt(object: JsonObject, key: string): JsonValue | undefined {
   return value;
 }
 
-const prefix = "plugins.bundled.summarize";
+const prefix = "plugins.shape.bundled.summarize";
 
 function savedProvider(config: JsonObject): string {
   const value = valueAt(config, `${prefix}.provider`);
@@ -108,20 +165,16 @@ function savedProvider(config: JsonObject): string {
   return isStringValue(value) ? value : "";
 }
 
-function savedEndpoint(config: JsonObject): string {
-  const value = valueAt(config, `${prefix}.endpoint`);
-
-  return isStringValue(value) ? value : "";
-}
-
 /** Whether a saved key belongs to a different destination than the draft's. */
 function movesKey(
   config: JsonObject,
   draft: Pick<ReviewDiffrSummarizerInput, "provider" | "endpoint">,
 ): boolean {
+  const endpoint = valueAt(config, `${prefix}.endpoint`);
+
   return (
     draft.provider !== savedProvider(config) ||
-    draft.endpoint !== savedEndpoint(config)
+    draft.endpoint !== (isStringValue(endpoint) ? endpoint : "")
   );
 }
 
@@ -151,27 +204,35 @@ function strings(value: JsonValue | undefined): string[] {
 }
 
 /**
- * What diffr's schema says about summaries: each provider's defaults, and
- * the default prompt with the link its description gives. Nothing when
- * diffr cannot describe its schema: the rest of Settings still works.
+ * Defaults supplied by diffr's schema for tag hiding and summary controls.
+ * If the schema cannot be read, resolved settings still work.
  */
-async function summaryDefaults(
+async function configDefaults(
   rootPath?: string,
-): Promise<Pick<ReviewDiffrConfig, "providers" | "defaultPrompt">> {
+): Promise<
+  Pick<ReviewDiffrConfig, "providers" | "defaultPrompt" | "defaultHiddenTags">
+> {
   let schema: JsonObject;
 
   try {
-    schema = json(await diffr(["config", "schema"], rootPath));
+    schema = json(await diffr({ command: "schema" }, rootPath));
   } catch {
     return {};
   }
 
   const options = valueAt(
     schema,
-    "properties.plugins.properties.bundled.properties.summarize.properties",
+    "properties.plugins.properties.shape.properties.bundled.properties.summarize.properties",
   );
 
-  if (!isJsonObject(options)) return {};
+  const defaultHiddenTags = strings(
+    valueAt(
+      schema,
+      "properties.plugins.properties.classify.properties.bundled.properties.hide.default",
+    ),
+  );
+
+  if (!isJsonObject(options)) return { defaultHiddenTags };
 
   const option = (name: string) =>
     isJsonObject(options[name]) ? options[name] : {};
@@ -200,6 +261,7 @@ async function summaryDefaults(
   const prompt = option("system_prompt");
 
   return {
+    defaultHiddenTags,
     providers,
     defaultPrompt: isStringValue(prompt.default) ? prompt.default : undefined,
   };
@@ -207,7 +269,7 @@ async function summaryDefaults(
 
 async function read(rootPath?: string): Promise<ReviewDiffrConfig> {
   const config = await values(rootPath);
-  const defaults = await summaryDefaults(rootPath);
+  const defaults = await configDefaults(rootPath);
   const saved = valueAt(config, `${prefix}.api_key`);
 
   const credentialSource =
@@ -217,16 +279,15 @@ async function read(rootPath?: string): Promise<ReviewDiffrConfig> {
         ? "environment"
         : "missing";
 
-  const plugins = config.plugins;
+  const plugins = valueAt(config, "plugins.shape");
 
   if (isJsonObject(plugins)) {
-    for (const namespace of Object.values(plugins)) {
-      if (!isJsonObject(namespace)) continue;
+    const entries = isJsonObject(plugins.bundled)
+      ? [...Object.values(plugins), ...Object.values(plugins.bundled)]
+      : Object.values(plugins);
 
-      for (const plugin of Object.values(namespace)) {
-        if (isJsonObject(plugin)) delete plugin.api_key;
-      }
-    }
+    for (const plugin of entries)
+      if (isJsonObject(plugin)) delete plugin.api_key;
   }
 
   return { values: config, credentialSource, ...defaults };
@@ -236,35 +297,35 @@ export function readDiffrConfig(rootPath?: string): Promise<ReviewDiffrConfig> {
   return serialized(() => read(rootPath));
 }
 
-export function diffrConfigValueText(value: JsonValue): string {
-  return isStringValue(value) ? value : JSON.stringify(value);
+export async function migrateDiffrConfig(
+  signal?: AbortSignal,
+): Promise<boolean> {
+  const result = json(
+    await diffr({ command: "migrate" }, undefined, { signal }),
+  );
+
+  if (result.changed === true) invalidateStructuralComparisons();
+
+  return result.changed === true;
 }
 
 async function writeSettings(
-  entries: [string, JsonValue][],
+  patch: JsonObject,
   rootPath?: string,
 ): Promise<ReviewDiffrConfig> {
   let changed = false;
   let error: string | undefined;
-  let current = await values(rootPath);
 
   try {
-    for (const [key, value] of entries) {
-      if (valueAt(current, key) === value) continue;
-      await diffr(
-        ["config", "set", key, diffrConfigValueText(value)],
-        rootPath,
-      );
-      changed = true;
-      // A write can clear others, such as a provider's endpoint and key.
-      current = await values(rootPath);
-    }
-  } catch {
-    error = changed
-      ? "Some settings were saved before diffr rejected a change. Check the current values and try again."
-      : "diffr could not save the setting. Check its configuration and the entered value.";
-  } finally {
+    const result = json(await diffr({ command: "set", patch }, rootPath));
+    changed = result.changed === true;
+
     if (changed) invalidateStructuralComparisons();
+  } catch (cause) {
+    error =
+      cause instanceof Error
+        ? cause.message
+        : "diffr could not save the settings.";
   }
 
   return { ...(await read(rootPath)), changed, error };
@@ -275,13 +336,16 @@ export function setDiffrConfigValue(
   value: JsonValue,
   rootPath?: string,
 ): Promise<ReviewDiffrConfig> {
-  if (
-    !/^[A-Za-z0-9_][A-Za-z0-9_-]*(\.[A-Za-z0-9_][A-Za-z0-9_-]*)*$/.test(key)
-  ) {
+  if (!/^[A-Za-z0-9_][A-Za-z0-9_-]*(\.[^.\r\n\0]+)*$/u.test(key)) {
     throw new Error("Invalid diffr config key.");
   }
 
-  return serialized(() => writeSettings([[key, value]], rootPath));
+  const parts = key.split(".");
+  let patch: JsonObject = { [parts.pop()!]: value };
+
+  for (const part of parts.reverse()) patch = { [part]: patch };
+
+  return serialized(() => writeSettings(patch, rootPath));
 }
 
 export function saveDiffrSummarizer(
@@ -313,40 +377,24 @@ export function saveDiffrSummarizer(
       };
     }
 
-    const entries: [string, JsonValue][] = [];
-
-    if (!draft.enabled) entries.push([`${prefix}.enabled`, false]);
-
-    // Clear a key before its destination changes and write a new one only
-    // after, so a failure part way never pairs a key with another vendor.
-    if (moving && savedKey) entries.push([`${prefix}.api_key`, ""]);
-    entries.push([`${prefix}.provider`, draft.provider]);
+    const summarize: JsonObject = {
+      enabled: draft.enabled,
+      provider: draft.provider,
+      endpoint: draft.endpoint,
+      model: draft.model,
+      tests: draft.tests,
+    };
 
-    // diffr clears a provider's endpoint when the provider changes, so a
-    // custom one kept across a switch is written again.
-    if (
-      draft.endpoint !== savedEndpoint(current.values) ||
-      (draft.endpoint && draft.provider !== savedProvider(current.values))
-    )
-      entries.push([`${prefix}.endpoint`, draft.endpoint]);
+    if (draft.apiKey) summarize.api_key = draft.apiKey;
+    else if (moving && savedKey) summarize.api_key = "";
 
-    if (draft.apiKey) entries.push([`${prefix}.api_key`, draft.apiKey]);
+    if (draft.systemPrompt.trim()) summarize.system_prompt = draft.systemPrompt;
 
-    // A blank prompt leaves diffr's own in place.
-    if (
-      draft.systemPrompt.trim() &&
-      draft.systemPrompt !== valueAt(current.values, `${prefix}.system_prompt`)
-    )
-      entries.push([`${prefix}.system_prompt`, draft.systemPrompt]);
-
-    entries.push(
-      [`${prefix}.model`, draft.model],
-      [`${prefix}.tests`, draft.tests],
+    return writeSettings(
+      // oxlint-disable-next-line anti-slop/no-shape-in-symbol-names -- Native diffr config key.
+      { plugins: { shape: { bundled: { summarize } } } },
+      rootPath,
     );
-
-    if (draft.enabled) entries.push([`${prefix}.enabled`, true]);
-
-    return writeSettings(entries, rootPath);
   });
 }
 
@@ -373,7 +421,7 @@ export async function testDiffrSummarizer(
       throw new Error("The summarizer is not available in this configuration.");
 
     const { provider, endpoint, model, systemPrompt } = parsed.data;
-    const providers = (await summaryDefaults(rootPath)).providers ?? [];
+    const providers = (await configDefaults(rootPath)).providers ?? [];
 
     const variables =
       providers.find((known) => known.id === provider)?.keyVariables ?? [];
@@ -410,10 +458,13 @@ export async function testDiffrSummarizer(
     await writeFile(
       join(directory, "diffr", "config.toml"),
       stringify({
-        version: 1,
+        version: 2,
         plugins: {
-          order: ["bundled.summarize"],
-          bundled: { summarize: options },
+          // oxlint-disable-next-line anti-slop/no-shape-in-symbol-names -- Native diffr v2 config key.
+          shape: {
+            order: ["bundled.summarize"],
+            bundled: { summarize: options },
+          },
         },
       }),
       { mode: 0o600 },
@@ -425,56 +476,47 @@ export async function testDiffrSummarizer(
     await writeFile(before, "");
     await writeFile(after, SUMMARY_SAMPLE);
 
-    const output = await diffr(
-      [
-        "--no-index",
-        "--format",
-        "ndjson",
-        "--stream-annotations",
-        "--",
-        before,
-        after,
-      ],
-      directory,
-      {
-        env: {
-          ...process.env,
-          ...Object.fromEntries(
-            providers
-              .flatMap((known) => known.keyVariables)
-              .map((name) => [name, ""]),
-          ),
-          ...(apiKey && variables[0] && { [variables[0]]: apiKey }),
-          XDG_CONFIG_HOME: directory,
-        },
-        signal: deadline,
+    const output = await diffr({ command: "diff", before, after }, directory, {
+      env: {
+        ...process.env,
+        ...Object.fromEntries(
+          providers
+            .flatMap((known) => known.keyVariables)
+            .map((name) => [name, ""]),
+        ),
+        ...(apiKey && variables[0] && { [variables[0]]: apiKey }),
+        XDG_CONFIG_HOME: directory,
       },
-    );
+      signal: deadline,
+    });
 
     try {
       const events = output.trim().split("\n").map(decodeStructuralDiffEvent);
       const complete = events.at(-1);
 
-      const annotation = events
+      const labels = (region: StructuralRegion): string[] => [
+        ...(region.visibility?.label ? [region.visibility.label] : []),
+        ...(region.kind === "fold" ? region.children.flatMap(labels) : []),
+      ];
+
+      const summary = events
         .flatMap((event) =>
-          event.type === "annotations" ? event.annotations : [],
+          event.type === "file" && event.diff?.type === "text"
+            ? [event.diff.rhs, event.diff.lhs].flatMap((source) =>
+                source ? labels(source.root) : [],
+              )
+            : [],
         )
-        .find((item) => item.label.trim());
+        .find((label) => label.trim());
 
       if (
         complete?.type === "complete" &&
         complete.failed === 0 &&
         !complete.aborted &&
-        !events.some(
-          (event) =>
-            (event.type === "annotations" || event.type === "file") &&
-            event.error,
-        ) &&
-        annotation
+        !events.some((event) => event.type === "file" && event.error) &&
+        summary
       ) {
-        return apiKey
-          ? annotation.label.split(apiKey).join("[redacted]")
-          : annotation.label;
+        return apiKey ? summary.split(apiKey).join("[redacted]") : summary;
       }
     } catch {
       /* Never return provider output or parser causes. */

package/src/server/headless-host.ts

@@ -12,6 +12,7 @@ import {
   reviewServerDiscoveryPath,
 } from "@review/server-discovery.js";
 
+import { migrateDiffrConfig } from "./diffr-config.js";
 import { GlobalReviewDesktopVerbRelay } from "./global-verb-relay.js";
 import { createNodeRequestListener } from "./hono-http.js";
 import {
@@ -72,6 +73,8 @@ export function withHeadlessServerLock<T>(
 async function serve(input: HeadlessServerInput) {
   if (input.signal.aborted) return;
 
+  await migrateDiffrConfig(input.signal);
+
   if (input.telemetry) await drainServerCrashReport(input.telemetry);
 
   const local = await openReviewProfile(input.stateDir, {

package/src/server/structural-diff.ts

@@ -1,17 +1,13 @@
 import { spawn } from "node:child_process";
-import { existsSync } from "node:fs";
-import path from "node:path";
 import { createInterface } from "node:readline";
 
+import { diffrBinaryPath } from "@dev.fast/diffr";
 import {
   STRUCTURAL_DIFF_WIRE_VERSION,
   type StructuralDiffEvent,
   type StructuralProblem,
   decodeStructuralDiffEvent,
 } from "@dev.fast/review-protocol";
-import { findReviewPackageRoot } from "@review/package-paths";
-
-import { installedFullDiffr } from "./diffr-languages.js";
 
 export type DiffComparison =
   | { kind: "trees"; base: string; head: string }
@@ -26,27 +22,17 @@ export interface StructuralDiffRequest {
   signal: AbortSignal;
 }
 
-export function diffrExecutable(
-  packageRoot = findReviewPackageRoot(import.meta.url),
-): string {
-  if (process.env.REVIEW_DIFFR_BINARY) return process.env.REVIEW_DIFFR_BINARY;
-
-  const full = installedFullDiffr(packageRoot);
+export function diffrExecutable(): string {
+  const executable = diffrBinaryPath();
 
-  if (full) return full;
+  if (!executable) throw diffrMissingError();
 
-  const bundled = path.join(
-    packageRoot,
-    "bin",
-    process.platform === "win32" ? "diffr.exe" : "diffr",
-  );
-
-  return existsSync(bundled) ? bundled : "diffr";
+  return executable;
 }
 
 export function diffrMissingError(): Error {
   return new Error(
-    `Cannot find diffr at ${diffrExecutable()}. Whiteboard Desktop bundles it at bin/diffr under its runtime; in a checkout, run \`pnpm --filter @dev.fast/whiteboard ensure:diffr\` or install diffr on PATH, or set REVIEW_DIFFR_BINARY to its executable.`,
+    "The bundled diffr executable is missing. Reinstall Whiteboard.",
   );
 }
 
@@ -59,15 +45,10 @@ export async function* structuralDiff(
   input: StructuralDiffRequest,
 ): AsyncGenerator<StructuralDiffEvent> {
   input.signal.throwIfAborted();
+  const executable = diffrExecutable();
   const comparison = input.comparison;
 
-  const args = [
-    "--repo",
-    input.repositoryPath,
-    "--format",
-    "ndjson",
-    "--stream-annotations",
-  ];
+  const args = ["--repo", input.repositoryPath, "--format", "ndjson"];
 
   switch (comparison.kind) {
     case "worktree":
@@ -88,11 +69,9 @@ export async function* structuralDiff(
 
   // The host inherits its own environment and runs from the repository, so
   // diffr reads the user's config and keys exactly as it would from a shell.
-  console.info(
-    `[Review] structural diff: ${diffrExecutable()} ${args.join(" ")}`,
-  );
+  console.info(`[Review] structural diff: ${executable} ${args.join(" ")}`);
 
-  const child = spawn(diffrExecutable(), args, {
+  const child = spawn(executable, args, {
     cwd: input.repositoryPath,
     stdio: ["ignore", "pipe", "pipe"],
     signal,
@@ -120,7 +99,6 @@ export async function* structuralDiff(
   let completed = false;
   let aborted: StructuralProblem | undefined;
   let failed = 0;
-  let annotationFailed = false;
   const lines = createInterface({ input: child.stdout, crlfDelay: Infinity });
 
   try {
@@ -152,8 +130,6 @@ export async function* structuralDiff(
 
         failed = event.failed;
         aborted = event.aborted;
-      } else if (event.type === "annotations") {
-        annotationFailed ||= event.error !== undefined;
       } else if (event.type !== "file") {
         throw new Error(`Unexpected diffr event: ${event.type}`);
       }
@@ -168,13 +144,10 @@ export async function* structuralDiff(
       throw new Error("diffr stream ended before completion.");
     }
 
-    // diffr exits 2 for file or enrichment failures already reported by the stream.
+    // diffr exits 2 for file failures already reported by the stream.
     const code = await exited;
 
-    if (
-      code !== 0 &&
-      !(code === 2 && (failed > 0 || annotationFailed || aborted !== undefined))
-    )
+    if (code !== 0 && !(code === 2 && (failed > 0 || aborted !== undefined)))
       throw exitError(code);
   } finally {
     clearTimeout(idle);