@stigmer/ink 3.1.1 → 3.1.3

package/src/components/FileChangeProgressBar.tsx

@@ -0,0 +1,122 @@
+import React from "react";
+import { Box, Text } from "ink";
+import type { FileChangeProgress } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import { kindLetter, progressEntryDisplayPath } from "../file-review.js";
+
+/** Props for {@link FileChangeProgressBar}. */
+export interface FileChangeProgressBarProps {
+  /**
+   * The transient mid-run progress snapshot for the active turn (DD-32). Feed
+   * this from `useSessionConversation().fileChangeProgress`. Renders nothing when
+   * undefined or when no files have changed yet — the server clears it once the
+   * turn's change set leaves CAPTURING, so the strip disappears exactly when the
+   * decision surface (`FileReviewPrompt`) takes over.
+   */
+  readonly progress: FileChangeProgress | undefined;
+  /**
+   * Whether to reveal the per-file list. The compact one-line summary always
+   * shows; the list is progressive disclosure. `SessionView` binds this to its
+   * existing Ctrl+O "expand" toggle so no new keybinding is introduced. Defaults
+   * to `false`.
+   */
+  readonly expanded?: boolean;
+}
+
+/**
+ * The terminal analogue of the web's non-interactive "N files changing…" strip
+ * (`@stigmer/react` `FileChangeProgressBar`), for a turn that is still running.
+ *
+ * WHY IT EXISTS. The transcript streams per-edit tool rows, but a change made by
+ * a shell command (a `sed`, a build step) has no tool row, and there is no
+ * running net-of-many-edits rollup until the turn ends. This strip fills that
+ * gap: a compact, non-interactive count of the workspace delta accumulating
+ * during the turn, sitting where the `FileReviewPrompt` will later appear. The
+ * two are mutually exclusive per turn (progress shows while CAPTURING; the prompt
+ * once AWAITING_REVIEW), so the strip hands off cleanly to the prompt.
+ *
+ * NEVER A DECISION SURFACE. Progress is non-authoritative and carries no file
+ * bodies — it is never reviewable or decidable, and it owns no keyboard input.
+ * The reviewed diff is the turn-boundary candidate (`FileReviewPrompt`). A
+ * secret-like path is surfaced by name with its counts withheld (zeroed), so the
+ * `+N −M` stat renders nothing for it. The quiet/dim register (no border)
+ * distinguishes it from the loud, bordered decision prompt.
+ *
+ * @example
+ * ```tsx
+ * const conv = useSessionConversation(sessionId, org);
+ * <FileChangeProgressBar progress={conv.fileChangeProgress} expanded={expandTools} />
+ * ```
+ */
+export function FileChangeProgressBar({
+  progress,
+  expanded = false,
+}: FileChangeProgressBarProps) {
+  if (!progress || progress.filesChanged === 0) return null;
+
+  const { filesChanged, linesAdded, linesRemoved, entries } = progress;
+  const hiddenCount = filesChanged - entries.length;
+
+  return (
+    <Box flexDirection="column" paddingLeft={1}>
+      <Box gap={1}>
+        <Text dimColor>✎</Text>
+        <Text dimColor>
+          {filesChanged} file{filesChanged === 1 ? "" : "s"} changing…
+        </Text>
+        <LineStats linesAdded={linesAdded} linesRemoved={linesRemoved} />
+      </Box>
+
+      {expanded && (
+        <Box flexDirection="column" paddingLeft={2}>
+          {entries.map((entry, idx) => {
+            const path = progressEntryDisplayPath(entry);
+            return (
+              <Box key={`${path}-${idx}`} gap={1}>
+                <Text dimColor>{kindLetter(entry.kind)}</Text>
+                <Text dimColor wrap="truncate-end">
+                  {path}
+                </Text>
+                <LineStats
+                  linesAdded={entry.linesAdded}
+                  linesRemoved={entry.linesRemoved}
+                />
+              </Box>
+            );
+          })}
+          {hiddenCount > 0 && (
+            <Box>
+              <Text dimColor>… and {hiddenCount} more</Text>
+            </Box>
+          )}
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+/**
+ * The `+N −M` stat for one file (or the whole turn), in the diff colour
+ * vocabulary. Renders nothing when both counts are zero — the honest signal that
+ * no count exists (binary or secret-withheld changes) — rather than a misleading
+ * `+0 -0`, matching the web `FileLineStats` contract.
+ *
+ * Kept module-local: this is the only consumer today. When `FileReviewPrompt`
+ * and `FileReviewRecord` gain `+N −M` (the deferred "CLI +N −M parity"
+ * follow-up), lift this into a shared ink atom (the analogue of `sdk/react`'s
+ * `FileReviewAtoms`) so the three surfaces cannot drift — do not copy it.
+ */
+function LineStats({
+  linesAdded,
+  linesRemoved,
+}: {
+  readonly linesAdded: number;
+  readonly linesRemoved: number;
+}) {
+  if (linesAdded === 0 && linesRemoved === 0) return null;
+  return (
+    <Text>
+      <Text color="green">+{linesAdded}</Text>
+      <Text color="red"> -{linesRemoved}</Text>
+    </Text>
+  );
+}

package/src/components/FileReviewPrompt.tsx

@@ -0,0 +1,328 @@
+import React, { useMemo, useState } from "react";
+import { Box, Text, useInput } from "ink";
+import type {
+  CapturedFileChange,
+  FileChangeSet,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import {
+  FileDecisionAction,
+  FileDecisionScope,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import {
+  changeSetReviewability,
+  fileReviewability,
+  deriveEffectiveVerdicts,
+  fileDecisionKey,
+  type FileDecisionOptions,
+} from "@stigmer/react";
+import { blockReasonNote, changeDisplayPath, kindLetter } from "../file-review.js";
+
+/** Props for {@link FileReviewPrompt}. */
+export interface FileReviewPromptProps {
+  /** The AWAITING_REVIEW change set this prompt decides. */
+  readonly changeSet: FileChangeSet;
+  /**
+   * Submit a decision for this set (or one file within it). Bound to the active
+   * execution by the caller; the terminal analogue of the web dock's
+   * `submitFileDecision`.
+   */
+  readonly onSubmit: (
+    changeSetId: string,
+    action: FileDecisionAction,
+    options?: FileDecisionOptions,
+  ) => void;
+  /** Keys (via `fileDecisionKey`) currently being submitted — drives busy state. */
+  readonly submittingDecisionKeys?: ReadonlySet<string>;
+  /** Per-decision failures, keyed via `fileDecisionKey`. */
+  readonly decisionErrors?: ReadonlyMap<string, Error>;
+  /**
+   * Whether this prompt owns the keyboard. False renders a read-only view (no
+   * `useInput`) so exactly one decision surface is interactive at a time.
+   * Defaults to `true`.
+   */
+  readonly isActive?: boolean;
+}
+
+/**
+ * The bulk approve/reject verb labels for a set, mirroring the web card's
+ * `bulkLabels`: "Keep" for a binary-only set (its bytes are applied as-is),
+ * "Approve" otherwise; "remaining" when some files are already decided.
+ */
+function bulkLabels(
+  total: number,
+  decided: number,
+  binaryOnly: boolean,
+): { approve: string; reject: string } {
+  const verb = binaryOnly ? "Keep" : "Approve";
+  if (total <= 1) return { approve: verb, reject: "Reject" };
+  if (decided > 0 && decided < total) {
+    return { approve: `${verb} remaining`, reject: "Reject remaining" };
+  }
+  return { approve: `${verb} all`, reject: "Reject all" };
+}
+
+interface BulkOption {
+  readonly label: string;
+  readonly shortcut: string;
+  readonly color: string;
+  readonly run: () => void;
+}
+
+/**
+ * The terminal file-review decision surface — the linear-log analogue of the
+ * web's composer-docked `FileReviewDock`/`FileReviewCard`.
+ *
+ * Renders `N files awaiting review` and, gated by `changeSetReviewability`:
+ * bulk Approve/Keep all + Reject all (a complete set is approvable as-is; a
+ * binary-only set is kept with an acknowledgement; a blocked set can only be
+ * rejected in bulk), plus a per-file mode (`f`) for keeping/discarding each file
+ * — the only way to resolve a blocked or mixed set, since the server refuses a
+ * whole-set approve unless every file is complete. Decisions carry the same
+ * digests (`aggregate_digest` / `file_digest`) and `acknowledge_unreviewable`
+ * semantics as the web; no decision-model change.
+ *
+ * Keyboard: `a` approve/keep all · `r` reject all · `f` per-file mode; in
+ * per-file mode ↑/↓ move, `k` keep, `d` discard, `esc` back. Input is gated by
+ * `isActive` so only one decision surface owns the keyboard at a time.
+ */
+export function FileReviewPrompt({
+  changeSet,
+  onSubmit,
+  submittingDecisionKeys,
+  decisionErrors,
+  isActive = true,
+}: FileReviewPromptProps) {
+  const [perFile, setPerFile] = useState(false);
+  const [selectedIndex, setSelectedIndex] = useState(0);
+
+  const changes = changeSet.changes;
+  const total = changes.length;
+  const reviewability = changeSetReviewability(changeSet);
+  const binaryOnly = reviewability === "binary-only";
+  const canBulkApprove = reviewability !== "blocked";
+
+  const verdicts = useMemo(
+    () => deriveEffectiveVerdicts(changeSet),
+    [changeSet],
+  );
+  const decidedCount = useMemo(() => {
+    let n = 0;
+    for (const c of changes) if (verdicts.has(c.id)) n++;
+    return n;
+  }, [changes, verdicts]);
+
+  const labels = bulkLabels(total, decidedCount, binaryOnly);
+
+  // Busy while any decision for THIS set is in flight (whole-set key or any
+  // per-file key). Blocks input to avoid a double-submit mid-request.
+  const busy = useMemo(() => {
+    if (!submittingDecisionKeys) return false;
+    for (const key of submittingDecisionKeys) {
+      if (key === changeSet.id || key.startsWith(`${changeSet.id}:`)) return true;
+    }
+    return false;
+  }, [submittingDecisionKeys, changeSet.id]);
+
+  const errorText = useMemo(() => {
+    if (!decisionErrors) return null;
+    for (const [key, err] of decisionErrors) {
+      if (key === changeSet.id || key.startsWith(`${changeSet.id}:`)) {
+        return err.message;
+      }
+    }
+    return null;
+  }, [decisionErrors, changeSet.id]);
+
+  const submitBulk = (action: FileDecisionAction) => {
+    onSubmit(changeSet.id, action, {
+      scope: FileDecisionScope.CHANGE_SET,
+      expectedDigest: changeSet.aggregateDigest,
+      acknowledgeUnreviewable: action === FileDecisionAction.APPROVE && binaryOnly,
+    });
+  };
+
+  const submitFile = (change: CapturedFileChange, action: FileDecisionAction) => {
+    onSubmit(changeSet.id, action, {
+      scope: FileDecisionScope.FILE,
+      fileChangeId: change.id,
+      expectedDigest: change.fileDigest,
+      acknowledgeUnreviewable:
+        action === FileDecisionAction.APPROVE &&
+        fileReviewability(change).kind === "binary",
+    });
+  };
+
+  // Rebuilt each render (cheap; 2-3 options) so the `run` closures always bind
+  // the current `changeSet`/`onSubmit` — a memo keyed on the labels would hold
+  // a stale submit closure when the set updates without changing its labels.
+  const bulkOptions: BulkOption[] = [];
+  if (canBulkApprove) {
+    bulkOptions.push({
+      label: labels.approve,
+      shortcut: "a",
+      color: "green",
+      run: () => submitBulk(FileDecisionAction.APPROVE),
+    });
+  }
+  bulkOptions.push({
+    label: labels.reject,
+    shortcut: "r",
+    color: "red",
+    run: () => submitBulk(FileDecisionAction.REJECT),
+  });
+  bulkOptions.push({
+    label: "Review files",
+    shortcut: "f",
+    color: "cyan",
+    run: () => {
+      setSelectedIndex(0);
+      setPerFile(true);
+    },
+  });
+
+  useInput(
+    (input, key) => {
+      if (busy) return;
+
+      if (perFile) {
+        if (key.escape) {
+          setPerFile(false);
+          return;
+        }
+        if (key.upArrow) {
+          setSelectedIndex((i) => (i > 0 ? i - 1 : total - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setSelectedIndex((i) => (i < total - 1 ? i + 1 : 0));
+          return;
+        }
+        const change = changes[selectedIndex];
+        if (!change) return;
+        if (input === "k") {
+          // Keep is refused for a file with no reviewable/keepable bytes.
+          if (fileReviewability(change).kind !== "unavailable") {
+            submitFile(change, FileDecisionAction.APPROVE);
+          }
+        } else if (input === "d") {
+          submitFile(change, FileDecisionAction.REJECT);
+        }
+        return;
+      }
+
+      // Bulk mode.
+      const match = bulkOptions.find((o) => o.shortcut === input.toLowerCase());
+      if (match) match.run();
+    },
+    { isActive: isActive && !busy },
+  );
+
+  return (
+    <Box
+      flexDirection="column"
+      paddingLeft={2}
+      paddingTop={1}
+      paddingBottom={1}
+      borderStyle="round"
+      borderColor="cyan"
+    >
+      <Box gap={1}>
+        <Text color="cyan" bold>
+          ✎ {total} file{total === 1 ? "" : "s"} awaiting review
+        </Text>
+      </Box>
+
+      {perFile ? (
+        <PerFileList
+          changes={changes}
+          verdicts={verdicts}
+          selectedIndex={selectedIndex}
+          interactive={isActive && !busy}
+        />
+      ) : (
+        <Box gap={2} marginTop={1} paddingLeft={2}>
+          {bulkOptions.map((opt) => (
+            <Text key={opt.shortcut} color={opt.color}>
+              [{opt.shortcut}] {opt.label}
+            </Text>
+          ))}
+        </Box>
+      )}
+
+      {busy && (
+        <Box paddingLeft={2} marginTop={1}>
+          <Text dimColor>Submitting...</Text>
+        </Box>
+      )}
+
+      {errorText && (
+        <Box paddingLeft={2} marginTop={1}>
+          <Text color="red">Decision failed: {errorText}</Text>
+        </Box>
+      )}
+
+      {!isActive && !perFile && (
+        <Box paddingLeft={2} marginTop={1}>
+          <Text dimColor italic>
+            Resolve the pending approval first
+          </Text>
+        </Box>
+      )}
+    </Box>
+  );
+}
+
+interface PerFileListProps {
+  readonly changes: readonly CapturedFileChange[];
+  readonly verdicts: ReadonlyMap<string, FileDecisionAction>;
+  readonly selectedIndex: number;
+  readonly interactive: boolean;
+}
+
+/** The per-file review list: kind letter, path, verdict/keepability, and a hint. */
+function PerFileList({
+  changes,
+  verdicts,
+  selectedIndex,
+  interactive,
+}: PerFileListProps) {
+  return (
+    <Box flexDirection="column" marginTop={1} paddingLeft={2}>
+      {changes.map((change, idx) => {
+        const selected = idx === selectedIndex;
+        const verdict = verdicts.get(change.id);
+        const note = blockReasonNote(change);
+        const decided =
+          verdict === FileDecisionAction.APPROVE
+            ? "kept"
+            : verdict === FileDecisionAction.REJECT
+              ? "discarded"
+              : null;
+        return (
+          <Box key={change.id} gap={1}>
+            <Text color={selected ? "cyan" : undefined}>
+              {selected ? "▸" : " "}
+            </Text>
+            <Text dimColor>{kindLetter(change.kind)}</Text>
+            <Text
+              color={selected ? "cyan" : undefined}
+              bold={selected}
+              wrap="truncate-end"
+            >
+              {changeDisplayPath(change)}
+            </Text>
+            {decided && <Text dimColor>({decided})</Text>}
+            {!decided && note && <Text color="yellow">— {note}</Text>}
+          </Box>
+        );
+      })}
+      <Box marginTop={1}>
+        <Text dimColor>
+          {interactive
+            ? "↑/↓ move · [k] keep · [d] discard · [esc] back"
+            : "read-only"}
+        </Text>
+      </Box>
+    </Box>
+  );
+}

package/src/components/FileReviewRecord.tsx

@@ -0,0 +1,63 @@
+import React from "react";
+import { Box, Text } from "ink";
+import type { FileChangeSet } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/filereview_pb";
+import {
+  FileChangeSetStatus,
+  FileDecisionAction,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { deriveEffectiveVerdicts } from "@stigmer/react";
+import {
+  changeDisplayPath,
+  kindLetter,
+  settledSummary,
+} from "../file-review.js";
+
+/** Props for {@link FileReviewRecord}. */
+export interface FileReviewRecordProps {
+  /** A settled (decided / reconciled / failed) change set to record. */
+  readonly fileChangeSet: FileChangeSet;
+}
+
+/**
+ * A read-only, append-only record of a SETTLED file-review change set — the
+ * terminal analogue of the web's in-thread `FileReviewRecordRow` (DD-27 D2).
+ *
+ * Its primary job is the no-stamped-row case: a set changed only via shell
+ * commands stamps no edit rows, so the per-row badges leave no trace and this
+ * record is the only evidence of what was reviewed and decided. Sets with
+ * stamped rows already carry their outcome on the (frozen) row badges; this
+ * record complements them with a one-line summary and file list.
+ */
+export function FileReviewRecord({ fileChangeSet }: FileReviewRecordProps) {
+  const failed = fileChangeSet.status === FileChangeSetStatus.FAILED;
+  const verdicts = deriveEffectiveVerdicts(fileChangeSet);
+  const summary = failed ? "review failed" : settledSummary(fileChangeSet);
+
+  return (
+    <Box flexDirection="column" paddingLeft={2}>
+      <Box gap={1}>
+        <Text dimColor>✎</Text>
+        <Text dimColor>File review — {summary}</Text>
+      </Box>
+      {fileChangeSet.changes.map((change) => {
+        const verdict = verdicts.get(change.id);
+        const label = failed
+          ? null
+          : verdict === FileDecisionAction.APPROVE
+            ? "kept"
+            : verdict === FileDecisionAction.REJECT
+              ? "discarded"
+              : "not reviewed";
+        return (
+          <Box key={change.id} paddingLeft={2} gap={1}>
+            <Text dimColor>{kindLetter(change.kind)}</Text>
+            <Text dimColor wrap="truncate-end">
+              {changeDisplayPath(change)}
+            </Text>
+            {label && <Text dimColor>({label})</Text>}
+          </Box>
+        );
+      })}
+    </Box>
+  );
+}