@gmickel/gno 1.30.7 → 1.32.0

package/src/serve/file-refactor-http.ts

@@ -0,0 +1,239 @@
+/**
+ * REST transport adapter for canonical reference-safe rename/move.
+ *
+ * Handlers must not implement link rewrite logic — they only build
+ * targets, call the core planner/apply service, and map typed results.
+ *
+ * @module src/serve/file-refactor-http
+ */
+
+import type {
+  FileRefactorApplyResult,
+  FileRefactorPreviewPlan,
+  FileRefactorReasonCode,
+} from "../core/file-refactors";
+
+import {
+  applyCanonicalFileRefactor,
+  buildCanonicalRefactorPlan,
+  buildDurableFileRefactorApplyDeps,
+  FILE_REFACTOR_APPLY_CONFIRMATION,
+  FILE_REFACTOR_SCHEMA_VERSION,
+  parseRefactorApplyConfirmation as parseCoreRefactorApplyConfirmation,
+  resolveMoveTarget,
+  resolveRenameTarget,
+} from "../core/file-refactors";
+
+export {
+  applyCanonicalFileRefactor,
+  buildCanonicalRefactorPlan,
+  buildDurableFileRefactorApplyDeps as buildFileRefactorApplyDeps,
+  resolveMoveTarget,
+  resolveRenameTarget,
+};
+
+export interface FileRefactorHttpError {
+  code: string;
+  message: string;
+  status: number;
+  details?: Record<string, unknown>;
+}
+
+export interface FileRefactorApplyHttpSuccess {
+  success: true;
+  uri: string;
+  path: string;
+  relPath: string;
+  planDigest: string;
+  status: FileRefactorApplyResult["status"];
+  apply: FileRefactorApplyResult;
+  refactorWarnings: {
+    warnings: string[];
+    backlinkCount: number;
+    wikiLinkCount: number;
+    markdownLinkCount: number;
+  };
+  warning?: string;
+}
+
+function warningsFromPlan(plan: FileRefactorPreviewPlan) {
+  return {
+    warnings: [...plan.safety.warnings],
+    backlinkCount: plan.safety.backlinkCount,
+    wikiLinkCount: plan.safety.wikiLinkCount,
+    markdownLinkCount: plan.safety.markdownLinkCount,
+  };
+}
+
+export function toRefactorPlanResponse(plan: FileRefactorPreviewPlan) {
+  return {
+    ...plan,
+    operation: plan.operation,
+    nextRelPath: plan.target.relPath,
+    nextUri: plan.target.uri,
+    refactorWarnings: warningsFromPlan(plan),
+  };
+}
+
+function reasonMessage(
+  status: FileRefactorApplyResult["status"],
+  reasonCode?: FileRefactorReasonCode
+): string {
+  switch (status) {
+    case "stale_plan":
+      return "This refactor plan is stale. Preview again, then confirm the exact plan digest.";
+    case "conflict":
+      return "Another workspace mutation is in progress or the target is unsafe. Retry after it finishes.";
+    case "unsupported":
+      if (
+        reasonCode === "capability_denied" ||
+        reasonCode === "read_only_document"
+      ) {
+        return "This document cannot be refactored in place from GNO.";
+      }
+      if (reasonCode === "occupied_target") {
+        return "A file with that name already exists at the destination";
+      }
+      return reasonCode
+        ? `Refactor cannot be applied (${reasonCode}).`
+        : "Refactor cannot be applied.";
+    case "failed_rolled_back":
+      if (reasonCode === "rollback_recovery_required") {
+        return "Refactor failed and needs recovery. Filesystem state may require manual inspection using the recovery journal id.";
+      }
+      return "Refactor failed and was rolled back. No partial file set was left behind.";
+    default:
+      return "Refactor failed.";
+  }
+}
+
+export function mapApplyResultToHttpError(
+  result: FileRefactorApplyResult
+): FileRefactorHttpError {
+  const reasonCode = "reasonCode" in result ? result.reasonCode : undefined;
+  const details: Record<string, unknown> = {
+    planDigest: result.planDigest,
+    status: result.status,
+    filesystem: result.filesystem,
+    indexConvergence: result.indexConvergence,
+  };
+  if (reasonCode) {
+    details.reasonCode = reasonCode;
+  }
+  if (result.filesystem.recoveryJournalId) {
+    details.recoveryJournalId = result.filesystem.recoveryJournalId;
+  }
+
+  if (result.status === "stale_plan") {
+    return {
+      code: "STALE_PLAN",
+      message: reasonMessage(result.status, reasonCode),
+      status: 409,
+      details,
+    };
+  }
+  if (result.status === "conflict") {
+    return {
+      code: "CONFLICT",
+      message: reasonMessage(result.status, reasonCode),
+      status: 409,
+      details,
+    };
+  }
+  if (result.status === "unsupported") {
+    if (
+      reasonCode === "capability_denied" ||
+      reasonCode === "read_only_document"
+    ) {
+      return {
+        code: "READ_ONLY",
+        message: reasonMessage(result.status, reasonCode),
+        status: 409,
+        details,
+      };
+    }
+    if (reasonCode === "occupied_target") {
+      return {
+        code: "CONFLICT",
+        message: reasonMessage(result.status, reasonCode),
+        status: 409,
+        details,
+      };
+    }
+    return {
+      code: "UNSUPPORTED",
+      message: reasonMessage(result.status, reasonCode),
+      status: 409,
+      details,
+    };
+  }
+  if (result.status === "failed_rolled_back") {
+    const recovery =
+      result.filesystem.state === "recovery_required" ||
+      reasonCode === "rollback_recovery_required";
+    return {
+      code: recovery ? "RECOVERY_REQUIRED" : "ROLLED_BACK",
+      message: reasonMessage(result.status, reasonCode),
+      status: 500,
+      details,
+    };
+  }
+
+  return {
+    code: "RUNTIME",
+    message: reasonMessage(result.status, reasonCode),
+    status: 500,
+    details,
+  };
+}
+
+export function mapApplyResultToHttpSuccess(input: {
+  plan: FileRefactorPreviewPlan;
+  result: FileRefactorApplyResult;
+  targetFullPath: string;
+  operationLabel: "renamed" | "moved";
+}): FileRefactorApplyHttpSuccess | FileRefactorHttpError {
+  const { plan, result, targetFullPath, operationLabel } = input;
+
+  if (
+    result.status !== "applied" &&
+    result.status !== "applied_with_sync_pending"
+  ) {
+    return mapApplyResultToHttpError(result);
+  }
+
+  const warning =
+    result.status === "applied_with_sync_pending"
+      ? `File ${operationLabel} on disk, but index refresh failed. Run Update All to reconcile the workspace.`
+      : undefined;
+
+  return {
+    success: true,
+    uri: plan.target.uri,
+    path: targetFullPath,
+    relPath: plan.target.relPath,
+    planDigest: result.planDigest,
+    status: result.status,
+    apply: result,
+    refactorWarnings: warningsFromPlan(plan),
+    warning,
+  };
+}
+
+export interface ParsedRefactorApplyConfirmation {
+  planDigest: string;
+  confirmation: typeof FILE_REFACTOR_APPLY_CONFIRMATION;
+  schemaVersion: typeof FILE_REFACTOR_SCHEMA_VERSION;
+}
+
+export function parseRefactorApplyConfirmation(body: {
+  planDigest?: unknown;
+  confirmation?: unknown;
+  schemaVersion?: unknown;
+}): ParsedRefactorApplyConfirmation | FileRefactorHttpError {
+  const parsed = parseCoreRefactorApplyConfirmation(body);
+  if ("error" in parsed) {
+    return { code: "VALIDATION", message: parsed.message, status: 400 };
+  }
+  return parsed;
+}

package/src/serve/public/components/RefactorImpactPreview.tsx

@@ -0,0 +1,227 @@
+/**
+ * Canonical refactor impact preview for rename/move dialogs.
+ * Scholarly Dusk vocabulary: rail-style labels, mono paths, amber caution.
+ *
+ * @module src/serve/public/components/RefactorImpactPreview
+ */
+
+import type { FileRefactorPreviewPlan } from "../../../core/file-refactor-contract";
+
+const UNRESOLVED_CLASSIFICATIONS = new Set([
+  "ambiguous",
+  "unsupported",
+  "malformed",
+  "invalid",
+]);
+
+function shortDigest(digest: string): string {
+  return `${digest.slice(0, 8)}…${digest.slice(-6)}`;
+}
+
+export interface RefactorImpactPreviewProps {
+  plan: FileRefactorPreviewPlan | null;
+  loading?: boolean;
+  confirmed: boolean;
+  onConfirmedChange: (confirmed: boolean) => void;
+  /** Accessible outcome message after apply (sync-pending, recovery, etc.). */
+  outcomeMessage?: string | null;
+  outcomeTone?: "warning" | "error" | "success";
+}
+
+export function RefactorImpactPreview({
+  plan,
+  loading = false,
+  confirmed,
+  onConfirmedChange,
+  outcomeMessage,
+  outcomeTone = "warning",
+}: RefactorImpactPreviewProps) {
+  if (loading && !plan) {
+    return (
+      <div
+        aria-busy="true"
+        aria-live="polite"
+        className="rounded-md border border-border/30 bg-muted/20 px-3 py-2 font-mono text-[11px] text-muted-foreground"
+      >
+        Computing reference impact…
+      </div>
+    );
+  }
+
+  if (!plan) {
+    return null;
+  }
+
+  const rewriteable = plan.examinedReferences.filter(
+    (ref) => ref.classification === "rewriteable"
+  );
+  const unresolved = plan.examinedReferences.filter((ref) =>
+    UNRESOLVED_CLASSIFICATIONS.has(ref.classification)
+  );
+  const affectedPaths = plan.affectedDocuments.map((doc) => doc.relPath);
+  const confirmId = `refactor-confirm-${plan.planDigest.slice(0, 12)}`;
+
+  const outcomeClass =
+    outcomeTone === "error"
+      ? "border-destructive/40 bg-destructive/10 text-destructive"
+      : outcomeTone === "success"
+        ? "border-primary/30 bg-primary/10 text-primary"
+        : "border-amber-500/30 bg-amber-500/10 text-amber-500";
+
+  return (
+    <div className="max-h-[40vh] space-y-3 overflow-y-auto pr-1">
+      <div className="space-y-1">
+        <div className="font-mono text-[10px] text-muted-foreground/60 uppercase tracking-[0.15em]">
+          Safety
+        </div>
+        <div
+          aria-live="polite"
+          className={
+            plan.canApply
+              ? "rounded-md border border-primary/25 bg-primary/10 px-3 py-2 text-[13px] text-primary"
+              : "rounded-md border border-destructive/40 bg-destructive/10 px-3 py-2 text-[13px] text-destructive"
+          }
+          role="status"
+        >
+          {plan.canApply
+            ? "Plan is safe to apply with the exact digest below."
+            : `Cannot apply: ${(plan.safety.blockingReasonCodes[0] ?? "blocked").replaceAll("_", " ")}.`}
+        </div>
+        <p className="font-mono text-[11px] text-muted-foreground/70 break-all">
+          Digest {shortDigest(plan.planDigest)}
+        </p>
+      </div>
+
+      <div className="space-y-1">
+        <div className="font-mono text-[10px] text-muted-foreground/60 uppercase tracking-[0.15em]">
+          Target
+        </div>
+        <p className="font-mono text-[11px] text-muted-foreground/80 break-all">
+          {plan.source.relPath} → {plan.target.relPath}
+        </p>
+        <p className="font-mono text-[10px] text-muted-foreground/50 tabular-nums">
+          {plan.safety.rewriteableCount} rewrite
+          {plan.safety.rewriteableCount === 1 ? "" : "s"} ·{" "}
+          {plan.safety.unchangedCount} unchanged · {unresolved.length}{" "}
+          unresolved
+        </p>
+      </div>
+
+      {affectedPaths.length > 0 && (
+        <div className="space-y-1">
+          <div className="font-mono text-[10px] text-muted-foreground/60 uppercase tracking-[0.15em]">
+            Affected documents
+          </div>
+          <ul className="space-y-0.5">
+            {affectedPaths.map((path) => (
+              <li
+                className="font-mono text-[11px] text-muted-foreground/80 break-all"
+                key={path}
+              >
+                {path}
+              </li>
+            ))}
+          </ul>
+        </div>
+      )}
+
+      {rewriteable.length > 0 && (
+        <div className="space-y-1">
+          <div className="font-mono text-[10px] text-muted-foreground/60 uppercase tracking-[0.15em]">
+            Rewrites
+          </div>
+          <ul className="space-y-1">
+            {rewriteable.slice(0, 12).map((ref) => (
+              <li
+                className="rounded-sm px-2 py-1 font-mono text-[11px] text-muted-foreground hover:bg-muted/20"
+                key={`${ref.documentRelPath}:${ref.startLine ?? 0}:${ref.startCol ?? 0}:${ref.originalDestination ?? ""}`}
+              >
+                <span className="text-foreground/90">
+                  {ref.documentRelPath}
+                </span>
+                <span className="text-muted-foreground/50"> · </span>
+                <span>
+                  {ref.originalDestination ?? "?"} →{" "}
+                  {ref.proposedDestination ?? "?"}
+                </span>
+              </li>
+            ))}
+            {rewriteable.length > 12 && (
+              <li className="font-mono text-[10px] text-muted-foreground/50">
+                +{rewriteable.length - 12} more
+              </li>
+            )}
+          </ul>
+        </div>
+      )}
+
+      {unresolved.length > 0 && (
+        <div className="space-y-1">
+          <div className="font-mono text-[10px] text-amber-500/70 uppercase tracking-[0.15em]">
+            Unresolved / unsupported
+          </div>
+          <ul className="space-y-1">
+            {unresolved.slice(0, 12).map((ref) => (
+              <li
+                className="rounded-sm border border-amber-500/20 bg-amber-500/5 px-2 py-1 font-mono text-[11px] text-amber-500/90"
+                key={`${ref.documentRelPath}:${ref.classification}:${ref.startLine ?? 0}:${ref.originalDestination ?? ""}`}
+              >
+                <span>
+                  {ref.documentRelPath}
+                  {ref.startLine ? `:${ref.startLine}` : ""}
+                </span>
+                <span className="opacity-60"> · {ref.classification}</span>
+                {ref.reasonCode && (
+                  <span className="opacity-60"> · {ref.reasonCode}</span>
+                )}
+              </li>
+            ))}
+            {unresolved.length > 12 && (
+              <li className="font-mono text-[10px] text-amber-500/60">
+                +{unresolved.length - 12} more
+              </li>
+            )}
+          </ul>
+        </div>
+      )}
+
+      {plan.safety.warnings.length > 0 && (
+        <div
+          className="rounded-md border border-amber-500/30 bg-amber-500/10 px-3 py-2 text-amber-500 text-sm"
+          role="status"
+        >
+          {plan.safety.warnings.map((warning) => (
+            <div key={warning}>{warning}</div>
+          ))}
+        </div>
+      )}
+
+      <div className="flex items-start gap-2 rounded-md border border-border/30 bg-muted/15 px-3 py-2">
+        <input
+          checked={confirmed}
+          className="mt-0.5 size-4 accent-primary"
+          disabled={!plan.canApply}
+          id={confirmId}
+          onChange={(event) => onConfirmedChange(event.target.checked)}
+          type="checkbox"
+        />
+        <label className="text-[13px] leading-snug" htmlFor={confirmId}>
+          Confirm exact plan digest{" "}
+          <span className="font-mono text-[11px] text-muted-foreground">
+            {shortDigest(plan.planDigest)}
+          </span>
+        </label>
+      </div>
+
+      {outcomeMessage && (
+        <div
+          aria-live="assertive"
+          className={`rounded-md border px-3 py-2 text-sm ${outcomeClass}`}
+          role="alert"
+        >
+          {outcomeMessage}
+        </div>
+      )}
+    </div>
+  );
+}