@mycadet/assistant 0.12.10 → 0.13.0

package/src/runtime/migrations/validation-results-screen.ts

@@ -1,469 +0,0 @@
-/**
- * Validation results screen — view model for the validate + preflight-review steps.
- *
- * Derives display state from the migration wizard state machine for rendering
- * a validation results and dry-run summary UI. Usable from macOS/iOS web views,
- * CLI, or any TypeScript consumer.
- *
- * The screen combines two wizard steps into one logical view:
- *   1. validate — bundle integrity and schema validation
- *   2. preflight-review — dry-run import analysis (what would change)
- *
- * View model states:
- *   - disabled: step is not yet accessible (earlier steps incomplete)
- *   - loading: validation or preflight analysis is in progress
- *   - validation-error: bundle validation failed with errors
- *   - preflight-error: preflight analysis failed
- *   - transport-error: network/HTTP error occurred
- *   - success: both validation and preflight passed, ready to proceed
- */
-
-import type {
-  ImportPreflightConflict,
-  ImportPreflightFileReport,
-  ImportPreflightSuccessResponse,
-  ValidateSuccessResponse,
-  ValidationError,
-} from "./migration-transport.js";
-import type {
-  MigrationWizardState,
-  StepError,
-  StepExecutorOptions,
-} from "./migration-wizard.js";
-import {
-  canRetryCurrentStep,
-  executePreflightStep,
-  executeValidateStep,
-  goBackTo,
-  isStepAccessible,
-  resetStepForRetry,
-} from "./migration-wizard.js";
-
-// ---------------------------------------------------------------------------
-// View model types
-// ---------------------------------------------------------------------------
-
-/** Summary counts for the preflight dry-run analysis. */
-export interface PreflightSummary {
-  totalFiles: number;
-  filesToCreate: number;
-  filesToOverwrite: number;
-  filesUnchanged: number;
-  filesToSkip: number;
-}
-
-/** A file entry in the preflight analysis, normalized for display. */
-export interface PreflightFileEntry {
-  path: string;
-  action: "create" | "overwrite" | "unchanged" | "skip";
-  bundleSize: number;
-  currentSize: number | null;
-  bundleSha256: string;
-  currentSha256: string | null;
-}
-
-/** A conflict detected during preflight analysis. */
-export interface PreflightConflictEntry {
-  code: string;
-  message: string;
-  path?: string;
-}
-
-/**
- * Discriminated union representing the current display state of the
- * validation results screen.
- */
-export type ValidationScreenState =
-  | { phase: "disabled" }
-  | { phase: "loading"; message: string }
-  | {
-      phase: "validation-error";
-      errors: ValidationError[];
-      canRetry: boolean;
-    }
-  | {
-      phase: "preflight-error";
-      error: StepError;
-      canRetry: boolean;
-    }
-  | {
-      phase: "transport-error";
-      error: StepError;
-      step: "validate" | "preflight-review";
-      canRetry: boolean;
-    }
-  | {
-      phase: "success";
-      validation: {
-        isValid: true;
-        manifest: ValidateSuccessResponse["manifest"];
-      };
-      preflight: {
-        summary: PreflightSummary;
-        files: PreflightFileEntry[];
-        conflicts: PreflightConflictEntry[];
-        manifest: ImportPreflightSuccessResponse["manifest"];
-      };
-      canContinue: boolean;
-    };
-
-// ---------------------------------------------------------------------------
-// State derivation
-// ---------------------------------------------------------------------------
-
-/**
- * Normalize an ImportPreflightFileReport to a display-friendly shape.
- */
-function normalizeFileReport(
-  report: ImportPreflightFileReport,
-): PreflightFileEntry {
-  return {
-    path: report.path,
-    action: report.action,
-    bundleSize: report.bundle_size,
-    currentSize: report.current_size,
-    bundleSha256: report.bundle_sha256,
-    currentSha256: report.current_sha256,
-  };
-}
-
-/**
- * Normalize an ImportPreflightConflict to a display-friendly shape.
- */
-function normalizeConflict(
-  conflict: ImportPreflightConflict,
-): PreflightConflictEntry {
-  return {
-    code: conflict.code,
-    message: conflict.message,
-    ...(conflict.path !== undefined ? { path: conflict.path } : {}),
-  };
-}
-
-/**
- * Derive the current validation screen state from the wizard state.
- *
- * This is a pure function — no side effects. Call it whenever the wizard
- * state changes to get the latest display state.
- */
-export function deriveValidationScreenState(
-  wizardState: MigrationWizardState,
-): ValidationScreenState {
-  const validateStep = wizardState.steps["validate"];
-  const preflightStep = wizardState.steps["preflight-review"];
-
-  // Check if the validate step is accessible at all
-  if (
-    !isStepAccessible(wizardState, "validate") &&
-    wizardState.currentStep !== "validate" &&
-    wizardState.currentStep !== "preflight-review"
-  ) {
-    // Also check if we're past these steps (success case from later steps)
-    if (
-      validateStep.status !== "success" ||
-      preflightStep.status !== "success"
-    ) {
-      return { phase: "disabled" };
-    }
-  }
-
-  // Validate step is loading
-  if (
-    wizardState.currentStep === "validate" &&
-    validateStep.status === "loading"
-  ) {
-    return { phase: "loading", message: "Validating bundle..." };
-  }
-
-  // Preflight step is loading
-  if (
-    wizardState.currentStep === "preflight-review" &&
-    preflightStep.status === "loading"
-  ) {
-    return { phase: "loading", message: "Analyzing import changes..." };
-  }
-
-  // Validate step idle (not yet started)
-  if (
-    wizardState.currentStep === "validate" &&
-    validateStep.status === "idle"
-  ) {
-    return { phase: "loading", message: "Preparing validation..." };
-  }
-
-  // Preflight step idle (not yet started, validation passed)
-  if (
-    wizardState.currentStep === "preflight-review" &&
-    preflightStep.status === "idle"
-  ) {
-    return { phase: "loading", message: "Preparing import analysis..." };
-  }
-
-  // Validate step errored
-  if (
-    wizardState.currentStep === "validate" &&
-    validateStep.status === "error"
-  ) {
-    // Check if this is a validation failure (bundle invalid) vs transport error
-    if (wizardState.validateResult && !wizardState.validateResult.is_valid) {
-      return {
-        phase: "validation-error",
-        errors: wizardState.validateResult.errors,
-        canRetry: canRetryCurrentStep(wizardState),
-      };
-    }
-
-    // Transport/network error
-    return {
-      phase: "transport-error",
-      error: validateStep.error ?? {
-        message: "Validation failed",
-        retryable: false,
-      },
-      step: "validate",
-      canRetry: canRetryCurrentStep(wizardState),
-    };
-  }
-
-  // Preflight step errored
-  if (
-    wizardState.currentStep === "preflight-review" &&
-    preflightStep.status === "error"
-  ) {
-    // Check if this is a preflight validation failure vs transport error
-    if (
-      wizardState.preflightResult &&
-      !wizardState.preflightResult.can_import
-    ) {
-      return {
-        phase: "preflight-error",
-        error: preflightStep.error ?? {
-          message: "Import preflight validation failed",
-          retryable: false,
-        },
-        canRetry: canRetryCurrentStep(wizardState),
-      };
-    }
-
-    // Transport/network error
-    return {
-      phase: "transport-error",
-      error: preflightStep.error ?? {
-        message: "Preflight analysis failed",
-        retryable: false,
-      },
-      step: "preflight-review",
-      canRetry: canRetryCurrentStep(wizardState),
-    };
-  }
-
-  // Both steps succeeded — show full results
-  if (
-    validateStep.status === "success" &&
-    preflightStep.status === "success" &&
-    wizardState.validateResult?.is_valid &&
-    wizardState.preflightResult?.can_import
-  ) {
-    const validateResult =
-      wizardState.validateResult as ValidateSuccessResponse;
-    const preflightResult =
-      wizardState.preflightResult as ImportPreflightSuccessResponse;
-
-    return {
-      phase: "success",
-      validation: {
-        isValid: true,
-        manifest: validateResult.manifest,
-      },
-      preflight: {
-        summary: {
-          totalFiles: preflightResult.summary.total_files,
-          filesToCreate: preflightResult.summary.files_to_create,
-          filesToOverwrite: preflightResult.summary.files_to_overwrite,
-          filesUnchanged: preflightResult.summary.files_unchanged,
-          filesToSkip: preflightResult.summary.files_to_skip,
-        },
-        files: preflightResult.files.map(normalizeFileReport),
-        conflicts: preflightResult.conflicts.map(normalizeConflict),
-        manifest: preflightResult.manifest,
-      },
-      canContinue: isStepAccessible(wizardState, "transfer"),
-    };
-  }
-
-  // Fallback: if we're on a step past preflight-review and both succeeded,
-  // still show success (viewing results from a later step)
-  if (validateStep.status === "success" && preflightStep.status === "success") {
-    const validateResult = wizardState.validateResult;
-    const preflightResult = wizardState.preflightResult;
-
-    if (validateResult?.is_valid && preflightResult?.can_import) {
-      const vr = validateResult as ValidateSuccessResponse;
-      const pr = preflightResult as ImportPreflightSuccessResponse;
-
-      return {
-        phase: "success",
-        validation: {
-          isValid: true,
-          manifest: vr.manifest,
-        },
-        preflight: {
-          summary: {
-            totalFiles: pr.summary.total_files,
-            filesToCreate: pr.summary.files_to_create,
-            filesToOverwrite: pr.summary.files_to_overwrite,
-            filesUnchanged: pr.summary.files_unchanged,
-            filesToSkip: pr.summary.files_to_skip,
-          },
-          files: pr.files.map(normalizeFileReport),
-          conflicts: pr.conflicts.map(normalizeConflict),
-          manifest: pr.manifest,
-        },
-        canContinue: isStepAccessible(wizardState, "transfer"),
-      };
-    }
-  }
-
-  return { phase: "disabled" };
-}
-
-// ---------------------------------------------------------------------------
-// Actions — delegate to wizard state machine
-// ---------------------------------------------------------------------------
-
-/**
- * Execute both the validate and preflight steps in sequence.
- *
- * Runs validation first; if it succeeds, automatically proceeds to
- * preflight analysis. Returns the final wizard state after both steps.
- */
-export async function executeValidationFlow(
-  state: MigrationWizardState,
-  options: StepExecutorOptions,
-): Promise<MigrationWizardState> {
-  // Run validation
-  let current = await executeValidateStep(state, options);
-
-  // If validation succeeded, the wizard advances to preflight-review.
-  // Automatically run the preflight step.
-  if (
-    current.currentStep === "preflight-review" &&
-    current.steps["validate"].status === "success"
-  ) {
-    current = await executePreflightStep(current, options);
-  }
-
-  return current;
-}
-
-/**
- * Retry the current step after an error.
- *
- * Resets the step to idle and re-executes the appropriate step.
- * If the validate step is retried and succeeds, automatically
- * proceeds to the preflight step.
- */
-export async function retryValidationFlow(
-  state: MigrationWizardState,
-  options: StepExecutorOptions,
-): Promise<MigrationWizardState> {
-  let reset = resetStepForRetry(state);
-
-  // Clear stale results so a new transport error isn't misclassified
-  // as a validation/preflight failure based on the previous attempt's result.
-  if (reset.currentStep === "validate") {
-    reset = { ...reset, validateResult: undefined };
-  } else if (reset.currentStep === "preflight-review") {
-    reset = { ...reset, preflightResult: undefined };
-  }
-
-  options.onStateChange?.(reset);
-
-  if (reset.currentStep === "validate") {
-    return executeValidationFlow(reset, options);
-  }
-
-  if (reset.currentStep === "preflight-review") {
-    return executePreflightStep(reset, options);
-  }
-
-  throw new Error(
-    `Cannot retry validation flow from step "${reset.currentStep}"`,
-  );
-}
-
-/**
- * Navigate back to the upload-bundle step.
- */
-export function goBackToUpload(
-  state: MigrationWizardState,
-): MigrationWizardState {
-  return goBackTo(state, "upload-bundle");
-}
-
-// ---------------------------------------------------------------------------
-// Query helpers
-// ---------------------------------------------------------------------------
-
-/**
- * Check if the validation results screen is accessible from the current state.
- */
-export function isValidationScreenAccessible(
-  state: MigrationWizardState,
-): boolean {
-  return (
-    isStepAccessible(state, "validate") ||
-    state.currentStep === "validate" ||
-    state.currentStep === "preflight-review"
-  );
-}
-
-/**
- * Get the file entries grouped by action for display.
- */
-export function groupFilesByAction(files: PreflightFileEntry[]): {
-  create: PreflightFileEntry[];
-  overwrite: PreflightFileEntry[];
-  unchanged: PreflightFileEntry[];
-  skip: PreflightFileEntry[];
-} {
-  const create: PreflightFileEntry[] = [];
-  const overwrite: PreflightFileEntry[] = [];
-  const unchanged: PreflightFileEntry[] = [];
-  const skip: PreflightFileEntry[] = [];
-
-  for (const file of files) {
-    switch (file.action) {
-      case "create":
-        create.push(file);
-        break;
-      case "overwrite":
-        overwrite.push(file);
-        break;
-      case "unchanged":
-        unchanged.push(file);
-        break;
-      case "skip":
-        skip.push(file);
-        break;
-    }
-  }
-
-  return { create, overwrite, unchanged, skip };
-}
-
-/**
- * Format a byte size as a human-readable string.
- */
-export function formatFileSize(bytes: number): string {
-  if (bytes <= 0) {
-    return "0 B";
-  }
-  const units = ["B", "KB", "MB", "GB"];
-  const exponent = Math.min(
-    Math.max(0, Math.floor(Math.log(bytes) / Math.log(1024))),
-    units.length - 1,
-  );
-  const value = bytes / Math.pow(1024, exponent);
-  return `${exponent === 0 ? value : value.toFixed(1)} ${units[exponent]}`;
-}