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

package/src/review-api/tool-failure.ts

@@ -0,0 +1,64 @@
+import type {
+  ReviewTelemetryErrorCategory,
+  ReviewTelemetryErrorName,
+} from "@review/review-telemetry.js";
+
+import { ReviewApiError } from "./client.js";
+import { ReviewInputError } from "./input-error.js";
+
+export interface ToolFailure {
+  errorName: ReviewTelemetryErrorName;
+  errorCategory: ReviewTelemetryErrorCategory;
+}
+
+/**
+ * Sort a failed agent tool call into the CLI's closed error vocabulary, so
+ * telemetry can tell an agent's bad input from a broken host. `connect`
+ * covers reaching the host and reading its catalog; `call` is the tool itself.
+ */
+export function toolFailure(
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Catch boundary: sorts whatever a tool call threw by its class.
+  error: unknown,
+  phase: "connect" | "call",
+): ToolFailure {
+  const status =
+    error instanceof ReviewApiError || error instanceof ReviewInputError
+      ? error.status
+      : undefined;
+
+  if (status === 400)
+    return { errorName: "usage_error", errorCategory: "user_input" };
+
+  if (status === 401)
+    return {
+      errorName: "desktop_connection_error",
+      errorCategory: "dependency",
+    };
+
+  if (status === 404)
+    return { errorName: "review_not_found", errorCategory: "local_state" };
+
+  if (status === 409)
+    return { errorName: "review_state_error", errorCategory: "local_state" };
+
+  if (status !== undefined)
+    return { errorName: "unexpected_error", errorCategory: "internal" };
+
+  if (phase === "connect")
+    return {
+      errorName: "desktop_connection_error",
+      errorCategory: "dependency",
+    };
+
+  // fetch rejects with a TypeError; a command whose reply was lost is rewrapped
+  // with that rejection as its cause; an abort is the agent canceling the call.
+  if (
+    error instanceof Error &&
+    (error instanceof TypeError ||
+      error.name === "AbortError" ||
+      error.cause !== undefined)
+  )
+    return { errorName: "network_error", errorCategory: "transport" };
+
+  return { errorName: "unexpected_error", errorCategory: "internal" };
+}

package/src/review-api/trace-schema.ts

@@ -0,0 +1,13 @@
+import { z } from "zod";
+
+export const traceSchema = z.strictObject({
+  label: z.string(),
+  events: z.array(
+    z.strictObject({
+      id: z.string().min(1),
+      role: z.enum(["user", "assistant", "tool"]),
+      text: z.string(),
+    }),
+  ),
+  provenance: z.enum(["client_supplied", "legacy_import"]).optional(),
+});

package/src/review-api/traces.ts

@@ -0,0 +1,119 @@
+import {
+  TraceConfigurationError,
+  TraceStorageDeniedError,
+  type TraceStorageKind,
+  isS3MockMode,
+  isTraceStorageConfigured,
+  listReviewTraceSessions,
+  loadReviewAgentTrace,
+  resolveTraceStorage,
+  selectTraceStorage,
+} from "@dev.fast/trace-core";
+
+import type { Pins } from "./document.js";
+
+export async function listPinnedTraces(
+  cwd: string,
+  pins: Pins,
+  override?: TraceStorageKind,
+) {
+  const selection = selectTraceStorage();
+  const sources: TraceStorageKind[] = [];
+
+  if (selection.s3?.credentials || isS3MockMode()) sources.push("s3");
+
+  if (selection.hosted) sources.push("hosted");
+
+  const result = {
+    ok: true as const,
+    configured: isTraceStorageConfigured(),
+    storage: override ?? selection.mode,
+    sources,
+  };
+
+  try {
+    if (selection.error)
+      return { ...result, storageError: selection.error, sessions: [] };
+    const storage = await resolveTraceStorage({ cwd, override });
+
+    if (!storage && (override ?? selection.mode) === "hosted")
+      return {
+        ...result,
+        storageError:
+          "The hosted trace store has no login on this machine. Run `whiteboard login` and open the review again.",
+        sessions: [],
+      };
+
+    return {
+      ...result,
+      sessions: await listReviewTraceSessions({
+        rootPath: cwd,
+        baseCommit: pins.base,
+        headCommit: pins.head,
+        storage,
+      }),
+    };
+  } catch (error) {
+    if (
+      error instanceof TraceStorageDeniedError ||
+      error instanceof TraceConfigurationError
+    )
+      return { ...result, storageError: error.message, sessions: [] };
+    throw error;
+  }
+}
+
+export async function readStoredTrace(
+  cwd: string,
+  sessionId: string,
+  trace?: string,
+  override?: TraceStorageKind,
+) {
+  try {
+    const storage = await resolveTraceStorage({ cwd, override });
+
+    const loaded = await loadReviewAgentTrace({
+      cwd,
+      sessionId,
+      trace,
+      storage,
+    });
+
+    if (!loaded)
+      return {
+        ok: false as const,
+        status: 404 as const,
+        error: `Trace not found for session ${sessionId}.`,
+      };
+
+    return {
+      ok: true as const,
+      parserVersion: loaded.parserVersion,
+      session: loaded.descriptor,
+      trace: loaded.traceName,
+      cacheStatus: loaded.cacheStatus,
+      subagents: loaded.subagents,
+      title: loaded.trace.title,
+      startedAt: loaded.trace.startedAt,
+      endedAt: loaded.trace.endedAt,
+      activeMs: loaded.trace.activeMs,
+      userTurns: loaded.trace.userTurns,
+      toolCalls: loaded.trace.toolCalls,
+      events: loaded.trace.events,
+    };
+  } catch (error) {
+    if (
+      error instanceof TraceStorageDeniedError ||
+      error instanceof TraceConfigurationError
+    )
+      return {
+        ok: false as const,
+        status:
+          error instanceof TraceStorageDeniedError
+            ? (403 as const)
+            : (400 as const),
+        error: error.message,
+      };
+    throw error;
+  }
+}

package/src/review-api/unsupported-files.integration.ts

@@ -0,0 +1,91 @@
+import { execFileSync } from "node:child_process";
+import {
+  mkdtempSync,
+  rmSync,
+  symlinkSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import { coverageProgress } from "@review/viewed-coverage";
+import { expect, it } from "vitest";
+
+import { createReviewApi } from "./http";
+import { openLocalReviewStore } from "./local-data";
+
+it.each([false, true])(
+  "omits unsupported files from progress, with text changes=%s",
+  async (textChanged) => {
+    const root = mkdtempSync(path.join(tmpdir(), "unsupported-files-"));
+
+    const git = (...args: string[]) =>
+      execFileSync("git", ["-C", root, ...args], { encoding: "utf8" }).trim();
+
+    const commit = () => {
+      git(
+        "-c",
+        "user.name=Test",
+        "-c",
+        "user.email=test@example.invalid",
+        "commit",
+        "-qm",
+        "Fixture",
+      );
+
+      return git("rev-parse", "HEAD");
+    };
+
+    const local = openLocalReviewStore(path.join(root, "reviews.db"));
+
+    try {
+      git("init", "-q", "-b", "main");
+      writeFileSync(path.join(root, "value.ts"), "export const value = 1;\n");
+      git("add", "value.ts");
+      const first = commit();
+      git("update-index", "--add", "--cacheinfo", `160000,${first},module`);
+      symlinkSync("value.ts", path.join(root, "link"));
+      git("add", "link");
+      const base = commit();
+
+      git("update-index", "--cacheinfo", `160000,${base},module`);
+      unlinkSync(path.join(root, "link"));
+      symlinkSync("other.ts", path.join(root, "link"));
+
+      if (textChanged)
+        writeFileSync(path.join(root, "value.ts"), "export const value = 2;\n");
+      git("add", "value.ts", "link");
+      const head = commit();
+      const { id } = await local.data.register(root);
+
+      const { reviewId } = await local.store.execute({
+        operation: {
+          type: "create",
+          title: "Unsupported files",
+          target: { kind: "commits", repositoryId: id, base, head },
+        },
+      });
+
+      const app = createReviewApi(local.store, local.data);
+
+      const response = await app.request(
+        `/${reviewId}/progress?mode=structural`,
+      );
+
+      expect(response.status).toBe(200);
+      const progress = await response.json();
+      expect(progress.files.map((file: { path: string }) => file.path)).toEqual(
+        textChanged ? ["value.ts"] : [],
+      );
+      expect(coverageProgress(progress.files).total).toEqual({
+        additions: textChanged ? 1 : 0,
+        deletions: textChanged ? 1 : 0,
+      });
+    } finally {
+      await local.data.close();
+      await local.store.close();
+      rmSync(root, { recursive: true, force: true });
+    }
+  },
+);