@narumitw/pi-sync 0.54.0 → 0.54.1

package/src/ui/merge-review.ts

@@ -1,28 +1,88 @@
 import type { ExtensionCommandContext, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { runDocumentReview } from "@narumitw/pi-tui-kit";
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import { defineMenu, runCustomInteraction, runDocumentReview, runMenu } from "@narumitw/pi-tui-kit";
+import { createSyncConfirmation, type SyncConfirmationChoice } from "./sync-confirmation.js";
+import { safeTerminalText } from "./terminal-text.js";
 
-/** Cell-exact scrolling in TUI and paginated observable confirmation in RPC. */
+type ReviewContext = ExtensionCommandContext | ExtensionContext;
+
+/** One approval screen; full details are optional and never authorize a transfer. */
 export async function confirmMergeReview(
-  ctx: ExtensionCommandContext | ExtensionContext,
+  ctx: ReviewContext,
   title: string,
   content: string,
   signal: AbortSignal | undefined,
   isCurrent: () => boolean,
-  confirmationLabel = "Apply merged transfer",
+  confirmationLabel = "apply changes",
+  summaryLines?: readonly string[],
 ) {
-  const result = await runDocumentReview(ctx, {
-    title,
-    content,
-    format: { kind: "text" },
-    viewportSize: "adaptive",
-    confirmation: { label: confirmationLabel },
-    hint: "close",
-    signal,
-    isCurrent,
-    onError: () => {},
-  });
-  if (result.kind === "error") throw new Error("Merge review failed; no transfer was performed.");
-  if (result.kind === "unsupported")
-    throw new Error("Merge review requires observable TUI or RPC; review the plan before using --yes.");
-  return result.kind === "confirmed";
+  const lines = summaryLines ?? [
+    ...content
+      .split("\n")
+      .slice(0, 6)
+      .map((line) => truncateToWidth(safeTerminalText(line), 100)),
+    "View details for the complete review.",
+  ];
+  while (isCurrent() && !signal?.aborted) {
+    const choice: { value: "cancel" | "approve" | "details" } = { value: "cancel" };
+    const menu = defineMenu<undefined, "confirm", "choose", ReviewContext>({
+      start: "confirm",
+      screens: {
+        confirm: () => ({
+          kind: "choice",
+          title,
+          lines,
+          initialItemId: "cancel",
+          items: [
+            { id: "cancel", label: "No, cancel" },
+            { id: "approve", label: `Yes, ${confirmationLabel}` },
+            { id: "details", label: "View details" },
+          ],
+          action: "choose",
+          hint: "close",
+        }),
+      },
+      actions: {
+        choose: ({ itemId }) => {
+          if (itemId === "approve" || itemId === "details") choice.value = itemId;
+          return { kind: "close" };
+        },
+      },
+    });
+    const result =
+      ctx.mode === "tui" && ctx.hasUI
+        ? await runCustomInteraction<SyncConfirmationChoice, ReviewContext>(ctx, {
+            create: ({ tui, theme, keybindings, complete }) =>
+              createSyncConfirmation({ title, lines, confirmationLabel, tui, theme, keybindings, complete }),
+            signal,
+            isCurrent,
+            onError: () => {},
+          })
+        : await runMenu(ctx, menu, { getState: () => undefined, signal, isCurrent, onError: () => {} });
+    if (!isCurrent() || signal?.aborted) return false;
+    if (result.kind === "error") throw new Error("Merge review failed; no transfer was performed.");
+    if (result.kind === "unsupported")
+      throw new Error("Merge review requires observable TUI or RPC; review the plan before using --yes.");
+    if (result.kind === "completed") choice.value = result.value;
+    else if (result.kind !== "closed") return false;
+    // Keep authorization separate from UI termination in both adapters.
+    if (choice.value === "approve") return true;
+    if (choice.value !== "details") return false;
+    const detail = await runDocumentReview(ctx, {
+      title: "Sync change details",
+      content,
+      format: { kind: "text" },
+      viewportSize: "adaptive",
+      hint: "back",
+      signal,
+      isCurrent,
+      onError: () => {},
+    });
+    if (!isCurrent() || signal?.aborted) return false;
+    if (detail.kind === "error") throw new Error("Merge review failed; no transfer was performed.");
+    if (detail.kind !== "cancelled" || detail.reason !== "back") return false;
+    // A fresh menu discards remembered selection: returning from details always selects No.
+    // Unlike Pi's native Yes-first dialog, approval requires moving off the safe default.
+  }
+  return false;
 }

package/src/ui/merged-sync-summary.ts

@@ -0,0 +1,128 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { PublicationCapability } from "../backends/sync-backend.js";
+import type { Snapshot } from "../snapshot/snapshot-types.js";
+import type { FileMergeDecision } from "../sync/file-merge-planner.js";
+import { fileHashMap } from "../sync/sync-state.js";
+import { safeTerminalText, snapshotPathLabel } from "./terminal-text.js";
+
+interface FileChange {
+  path: string;
+  action: "Add" | "Update" | "Delete";
+}
+
+export interface MergedSyncSummaryInput {
+  setupName: string;
+  destination: string;
+  localBefore: Snapshot;
+  localAfter: Snapshot;
+  remoteBefore: Snapshot;
+  remoteAfter: Snapshot;
+  publish: boolean;
+  sessions: boolean;
+  groups: readonly { paths: readonly string[] }[];
+  decisions: readonly FileMergeDecision[];
+  capability: PublicationCapability;
+}
+
+/** Presentation only: counts describe snapshot differences, not planner decisions. */
+export function mergedSyncSummary(input: MergedSyncSummaryInput) {
+  const local = changes(input.localBefore, input.localAfter);
+  const remote = changes(input.remoteBefore, input.remoteAfter);
+  const all = [...local, ...remote];
+  const updatesOnly = all.length > 0 && all.every((change) => change.action === "Update");
+  const verb = updatesOnly ? "Update" : "Apply changes to";
+  const title =
+    local.length && remote.length
+      ? "Apply local and remote changes?"
+      : all.length
+        ? `${verb} ${all.length} ${local.length ? "local" : "remote"} ${all.length === 1 ? "file" : "files"}?`
+        : input.publish
+          ? "Publish a new remote snapshot?"
+          : "Pi Sync is already up to date.";
+  const confirmationLabel =
+    local.length && remote.length
+      ? "apply local and remote changes"
+      : all.length
+        ? `${updatesOnly ? "update" : "apply changes to"} ${local.length ? "local" : "remote"} ${all.length === 1 ? "file" : "files"}`
+        : "publish remote snapshot";
+  const sources = new Map(
+    input.decisions.filter((item) => item.kind === "accepted").map((item) => [item.path, item.source]),
+  );
+  const label = (change: FileChange, side: "local" | "remote") => {
+    const source = sources.get(change.path);
+    const suffix =
+      source === "merged"
+        ? " (merged content)"
+        : side === "local" && source === "remote"
+          ? change.action === "Delete"
+            ? " (deleted remotely)"
+            : " from remote"
+          : "";
+    return `${change.action} ${snapshotPathLabel(change.path)}${suffix}`;
+  };
+  const section = (items: FileChange[], side: "local" | "remote", compact: boolean) => {
+    const heading = side === "local" ? "Local changes" : "Remote file changes";
+    if (!items.length) return [`${heading}: none`];
+    const counts = ["Add", "Update", "Delete"].flatMap((action) => {
+      const count = items.filter((item) => item.action === action).length;
+      return count ? [`${count} ${action.toLowerCase()}`] : [];
+    });
+    return [
+      `${heading}: ${counts.join(", ")}`,
+      ...(compact ? items.slice(0, 3) : items).map(
+        (item) => `  ${compact ? truncateToWidth(label(item, side), 80) : label(item, side)}`,
+      ),
+      ...(compact && items.length > 3 ? [`  ${items.length - 3} more files — View details`] : []),
+    ];
+  };
+  const context = [`Setup: ${safeTerminalText(input.setupName)}`, `Remote: ${safeTerminalText(input.destination)}`];
+  const safety = [
+    `Remote snapshot publication: ${input.publish ? "yes" : "no"}`,
+    `Sessions: ${input.sessions ? "included — may contain private conversations" : "not included"}`,
+    input.groups.length
+      ? `Unresolved groups: ${input.groups.length} — these paths stay unchanged on each side`
+      : "Conflicts: none",
+    ...(input.publish && input.capability === "read-check-write-verify"
+      ? ["Warning: simultaneous remote writes can still race; visible changes are rejected."]
+      : []),
+    ...(input.publish && input.capability === "conditional-required"
+      ? ["Remote publication requires verified conditional writes; verification failure stops the transfer."]
+      : []),
+    "The current session is protected. A backup and recovery journal will be saved.",
+    "Resources will not reload automatically.",
+  ];
+  return {
+    title,
+    confirmationLabel,
+    lines: [
+      ...context.map((line) => truncateToWidth(line, 100)),
+      ...section(local, "local", true),
+      ...section(remote, "remote", true),
+      ...safety,
+    ],
+    content: [
+      ...context,
+      "",
+      ...section(local, "local", false),
+      "",
+      ...section(remote, "remote", false),
+      "",
+      ...safety,
+      ...input.groups.flatMap((group) =>
+        group.paths.map((filePath) => `Unchanged (unresolved): ${snapshotPathLabel(filePath)}`),
+      ),
+    ].join("\n"),
+  };
+}
+
+function changes(before: Snapshot, after: Snapshot): FileChange[] {
+  const beforeMap = fileHashMap(before);
+  const afterMap = fileHashMap(after);
+  return [...new Set([...Object.keys(beforeMap), ...Object.keys(afterMap)])]
+    .sort()
+    .flatMap((filePath): FileChange[] => {
+      if (!Object.hasOwn(beforeMap, filePath)) return [{ path: filePath, action: "Add" }];
+      if (!Object.hasOwn(afterMap, filePath)) return [{ path: filePath, action: "Delete" }];
+      return beforeMap[filePath] !== afterMap[filePath] ? [{ path: filePath, action: "Update" }] : [];
+    });
+}

package/src/ui/sync-confirmation.ts

@@ -0,0 +1,153 @@
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, SelectList, type TUI, type TuiMouseEvent, truncateToWidth } from "@earendil-works/pi-tui";
+import { HorizontalRule, hardWrapTerminalDocument, sanitizeTerminalText } from "@narumitw/pi-tui-kit";
+
+export type SyncConfirmationChoice = "cancel" | "approve" | "details";
+
+/** Kit choice context is clipped on short terminals; this summary must remain reviewable. */
+export function createSyncConfirmation(options: {
+  title: string;
+  lines: readonly string[];
+  confirmationLabel: string;
+  tui: TUI;
+  theme: Theme;
+  keybindings: KeybindingsManager;
+  complete(choice: SyncConfirmationChoice): void;
+}) {
+  const { tui, theme, keybindings } = options;
+  const choices: SyncConfirmationChoice[] = ["cancel", "approve", "details"];
+  const list = new SelectList(
+    [
+      { value: "cancel", label: "No, cancel" },
+      { value: "approve", label: `Yes, ${sanitizeTerminalText(options.confirmationLabel)}` },
+      { value: "details", label: "View details" },
+    ],
+    3,
+    {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.fg("accent", text),
+      description: (text) => theme.fg("muted", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("muted", text),
+    },
+  );
+  const rule = new HorizontalRule({ ruleStyle: (text) => theme.fg("border", text) });
+  let selected = 0;
+  let offset = 0;
+  let maximumOffset = 0;
+  let lastWidth = 0;
+  let lastRows = 0;
+  let seen = new Set<number>();
+  let summary: readonly string[] = [];
+  let reviewed = false;
+  let disposed = false;
+  let finished = false;
+  let summaryStart = 0;
+  let summaryEnd = 0;
+  let actionsStart = 0;
+  const finish = (choice: SyncConfirmationChoice) => {
+    if (disposed || finished) return;
+    finished = true;
+    options.complete(choice);
+  };
+  const select = (index: number) => {
+    selected = (index + choices.length) % choices.length;
+    list.setSelectedIndex(selected);
+  };
+  list.onSelectionChange = (item) => {
+    selected = Math.max(0, choices.indexOf(item.value as SyncConfirmationChoice));
+  };
+  list.onSelect = (item) => {
+    const choice = choices[selected] ?? "cancel";
+    if (item.value === choice && (choice !== "approve" || reviewed)) finish(choice);
+  };
+  const component = {
+    render(width: number, expose = true): string[] {
+      if (!Number.isFinite(width) || width <= 0) {
+        reviewed = false;
+        return [];
+      }
+      const cells = Math.floor(width);
+      const rows = Math.max(1, Math.floor(tui.terminal.rows) - 3);
+      if (cells !== lastWidth || rows !== lastRows) {
+        // Reflow can expose previously unseen rows or hide the selected action.
+        // Reset proof and selection rather than carry approval across a resize.
+        summary = options.lines.flatMap((line) => hardWrapTerminalDocument(line, cells));
+        seen = new Set();
+        offset = 0;
+        select(0);
+        lastWidth = cells;
+        lastRows = rows;
+      }
+      const framed = rows >= 9;
+      const actions = list.render(cells);
+      const viewport = Math.max(0, rows - actions.length - 3 - (framed ? 2 : 0));
+      maximumOffset = Math.max(0, summary.length - viewport);
+      offset = Math.min(offset, maximumOffset);
+      const visible = summary.slice(offset, offset + viewport);
+      if (expose) for (let index = offset; index < offset + visible.length; index++) seen.add(index);
+      reviewed = viewport > 0 && seen.size === summary.length;
+      // Describe actions without advertising configured keys that can be invalid,
+      // aliased, or shadowed by an earlier cancellation/navigation binding.
+      const hint = reviewed ? "Select an action." : "Navigation keys scroll the summary before selecting Yes.";
+      const body = [
+        theme.fg("accent", theme.bold(hardWrapTerminalDocument(options.title, cells).join(" "))),
+        ...visible.map((line) => theme.fg("text", line)),
+        theme.fg(
+          "muted",
+          `Summary ${visible.length ? offset + 1 : 0}-${offset + visible.length}/${summary.length}${reviewed ? "" : " — review before Yes"}`,
+        ),
+        ...actions,
+        theme.fg("dim", hint),
+      ];
+      summaryStart = Number(framed) + 1;
+      summaryEnd = summaryStart + visible.length;
+      actionsStart = summaryEnd + 1;
+      const frame = framed ? [...rule.render(cells), ...body, ...rule.render(cells)] : body;
+      // Very small terminals cannot display the summary and all choices together.
+      // Keep cancellation available, but never approve a zero-row summary viewport.
+      return frame.slice(0, rows).map((line) => truncateToWidth(line, cells, ""));
+    },
+    invalidate() {
+      list.invalidate();
+      rule.invalidate();
+    },
+    handleInput(data: string) {
+      if (disposed || finished) return;
+      if (matchesKey(data, Key.ctrl("c")) || keybindings.matches(data, "tui.select.cancel")) {
+        finish("cancel");
+        return;
+      }
+      // Refresh height/width proof before handling an input racing with terminal resize.
+      component.render(tui.terminal.columns ?? lastWidth, false);
+      if (keybindings.matches(data, "tui.select.up")) {
+        if (!reviewed || (selected === 0 && offset > 0)) offset = Math.max(0, offset - 1);
+        else select(selected - 1);
+      } else if (keybindings.matches(data, "tui.select.down")) {
+        if (!reviewed || (selected === 0 && offset < maximumOffset)) offset = Math.min(maximumOffset, offset + 1);
+        else select(selected + 1);
+      } else if (keybindings.matches(data, "tui.select.confirm")) {
+        const choice = choices[selected] ?? "cancel";
+        if (choice !== "approve" || reviewed) finish(choice);
+      }
+      tui.requestRender();
+    },
+    handleMouse(event: TuiMouseEvent) {
+      if (disposed || finished || event.width !== lastWidth) return undefined;
+      component.render(event.width, false);
+      if (event.y >= summaryStart && event.y < summaryEnd && event.type === "wheel" && event.wheelDelta) {
+        offset = Math.max(0, Math.min(maximumOffset, offset + (event.wheelDelta < 0 ? -1 : 1)));
+        select(0);
+        tui.requestRender();
+        return { handled: true, render: true };
+      }
+      if (event.y < actionsStart || event.y >= actionsStart + choices.length || event.y >= lastRows) return undefined;
+      return list.handleMouse({ ...event, y: event.y - actionsStart, height: choices.length });
+    },
+    dispose() {
+      disposed = true;
+      seen.clear();
+    },
+  };
+  return component;
+}