@rehearsal-db/core 0.1.0-beta.4 → 0.1.0-beta.5

package/scripts/operations/rehearsal/rehearsal_cli.mjs

@@ -36,9 +36,11 @@ import {
 import { createSyntheticBaselineFromFiles } from "../../lib/rehearsal/baseline_builder.mjs";
 import {
   applyBaselinePreparation,
+  inspectBaselineInputFiles,
   planBaselinePreparation,
   summarizeBaselinePreparation,
 } from "../../lib/rehearsal/baseline_preparation.mjs";
+import { discoverBaselineInputFiles } from "../../lib/rehearsal/input_discovery.mjs";
 import {
   applyRehearsalSetup,
   inspectRehearsalNodeRuntime,
@@ -49,8 +51,11 @@ import { formatCount } from "../../lib/rehearsal/human_output.mjs";
 import {
   applyReviewedPolicy,
   completePolicyDraft,
+  createSafeTablePreset,
   readReviewablePolicyDraft,
+  suggestPolicyExceptionColumns,
 } from "../../lib/rehearsal/policy_review.mjs";
+import { collectRehearsalSupportReport } from "../../lib/rehearsal/support_report.mjs";
 
 const packageRoot = fileURLToPath(new URL("../../..", import.meta.url));
 const projectRoot = process.cwd();
@@ -273,6 +278,7 @@ const promptForChoice = async ({ message, options, flags = {} }) => {
   if (useStyledPrompts(flags)) {
     const selected = await prompts.select({
       message,
+      maxItems: options.length,
       options: options.map((option) => ({
         value: option,
         label: option.label,
@@ -341,7 +347,7 @@ const promptForPath = async ({
       placeholder: defaultValue ?? (optional ? "Leave blank for none" : ""),
       defaultValue,
       validate: (value) => {
-        const resolved = String(value ?? defaultValue ?? "").trim();
+        const resolved = String(value || defaultValue || "").trim();
         if (!optional && !resolved) return "Enter a value.";
         return resolved && validate ? validate(resolved) : undefined;
       },
@@ -375,16 +381,107 @@ const promptForPath = async ({
   }
 };
 
+const promptForDiscoveredPath = async ({
+  message,
+  candidates,
+  optional = false,
+  flags,
+}) => {
+  if (candidates.length === 0) {
+    return promptForPath({ message, optional, flags });
+  }
+  const noneValue = "\0none";
+  const manualValue = "\0manual";
+  const selected = await promptForSelection({
+    message,
+    flags,
+    options: [
+      ...(optional
+        ? [
+            {
+              label: "No storage assets",
+              hint: "Continue without an asset manifest",
+              value: noneValue,
+            },
+          ]
+        : []),
+      ...candidates.map((path) => ({ label: path, value: path })),
+      { label: "Enter another path", value: manualValue },
+    ],
+  });
+  if (!selected || selected === noneValue) return undefined;
+  if (selected !== manualValue) return selected;
+  return promptForPath({ message, optional, flags });
+};
+
 const promptForSelection = async ({ message, options, flags }) => {
   const selected = await promptForChoice({ message, options, flags });
   return selected?.value;
 };
 
-const firstExistingPath = async (candidates) => {
-  for (const candidate of candidates) {
-    if (await pathExists(join(projectRoot, candidate))) return candidate;
+const promptForMultipleChoice = async ({
+  message,
+  options,
+  initialValues = [],
+  flags,
+}) => {
+  if (useStyledPrompts(flags)) {
+    const selected = await prompts.multiselect({
+      message,
+      options: options.map((option) => ({
+        value: option.value,
+        label: option.label,
+        hint: option.hint,
+      })),
+      initialValues,
+      required: false,
+    });
+    return prompts.isCancel(selected) ? undefined : selected;
+  }
+  const initial = new Set(initialValues);
+  console.log("");
+  console.log(message);
+  for (const [index, option] of options.entries()) {
+    console.log(
+      `  ${index + 1}. ${option.label}${initial.has(option.value) ? " (suggested)" : ""}`,
+    );
+  }
+  const defaultNumbers = options
+    .map((option, index) => (initial.has(option.value) ? index + 1 : undefined))
+    .filter(Boolean)
+    .join(",");
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+  try {
+    while (true) {
+      const suffix = defaultNumbers ? ` [${defaultNumbers}]` : " [none]";
+      const answer = (
+        await prompt.question(
+          `Choose comma-separated numbers, all, or none${suffix}: `,
+        )
+      )
+        .trim()
+        .toLowerCase();
+      if (!answer) return [...initialValues];
+      if (answer === "none") return [];
+      if (answer === "all") return options.map((option) => option.value);
+      const indexes = answer.split(",").map((value) => Number(value.trim()));
+      if (
+        indexes.length > 0 &&
+        indexes.every(
+          (index) =>
+            Number.isInteger(index) && index >= 1 && index <= options.length,
+        )
+      ) {
+        return [...new Set(indexes)].map((index) => options[index - 1].value);
+      }
+      console.log(`Choose numbers from 1 to ${options.length}, all, or none.`);
+    }
+  } finally {
+    prompt.close();
   }
-  return undefined;
 };
 
 const inspectGuidedProject = async (planOptions) => {
@@ -467,116 +564,180 @@ const reviewPolicyInteractively = async ({ state, flags }) => {
     (total, table) => total + (table.columns?.length ?? 0),
     0,
   );
-  let reviewedColumns = 0;
+  const tableSummaries = [];
+  let individuallyReviewed = 0;
   if (useStyledPrompts(flags)) {
     prompts.note(
       [
-        `${formatCount(totalColumns, "column")} require explicit review.`,
+        `${formatCount(totalColumns, "column")} across ${formatCount(draft.tables.length, "table")} require explicit review.`,
         "No row values are displayed or changed by this step.",
-        "The safest replacement-oriented choices appear first.",
+        "Safe defaults replace values, mark generated NEVER and identity NO, and set no foreign key.",
+        "Likely structural columns start selected for individual review.",
       ].join("\n"),
       "Review the script",
     );
   }
+  const reviewColumn = async ({ table, column }) => {
+    individuallyReviewed += 1;
+    const label = `${table}.${column}`;
+    const action = await promptForSelection({
+      message: `${label}: how should this value be handled?`,
+      flags,
+      options: [
+        {
+          label: "Replace with synthetic data",
+          hint: "Safest default",
+          value: "REPLACE WITH SYNTHETIC",
+        },
+        {
+          label: "Pseudonymize consistently",
+          hint: "Stable links without original values",
+          value: "PSEUDONYMIZE",
+        },
+        {
+          label: "Derive a safe value",
+          value: "DERIVE",
+        },
+        { label: "Exclude this field", value: "EXCLUDE" },
+        {
+          label: "Keep exactly",
+          hint: "Only for values explicitly safe to retain",
+          value: "KEEP EXACTLY",
+        },
+      ],
+    });
+    if (!action) throw new Error("Policy review was cancelled.");
+    const generated = await promptForSelection({
+      message: `${label}: is this column always database-generated?`,
+      flags,
+      options: [
+        { label: "No", value: "NEVER" },
+        { label: "Yes", value: "ALWAYS" },
+      ],
+    });
+    if (!generated) throw new Error("Policy review was cancelled.");
+    const identity = await promptForSelection({
+      message: `${label}: is this an identity column?`,
+      flags,
+      options: [
+        { label: "No", value: "NO" },
+        { label: "Yes", value: "YES" },
+      ],
+    });
+    if (!identity) throw new Error("Policy review was cancelled.");
+    const hasForeignKey = await promptForConfirmation(
+      `${label}: does this column reference another table?`,
+      flags,
+      { cancelValue: null },
+    );
+    if (hasForeignKey === null) {
+      throw new Error("Policy review was cancelled.");
+    }
+    let foreignKey = null;
+    if (hasForeignKey) {
+      const schema = await promptForPath({
+        message: `${label}: referenced schema`,
+        defaultValue: "public",
+        flags,
+        validate: (value) =>
+          /^[a-z][a-z0-9_]{0,62}$/u.test(value)
+            ? undefined
+            : "Use a lowercase PostgreSQL identifier.",
+      });
+      const referencedTable = await promptForPath({
+        message: `${label}: referenced table`,
+        flags,
+        validate: (value) =>
+          /^[a-z][a-z0-9_]{0,62}$/u.test(value)
+            ? undefined
+            : "Use a lowercase PostgreSQL identifier.",
+      });
+      const referencedColumn = await promptForPath({
+        message: `${label}: referenced column`,
+        flags,
+        validate: (value) =>
+          /^[a-z][a-z0-9_]{0,62}$/u.test(value)
+            ? undefined
+            : "Use a lowercase PostgreSQL identifier.",
+      });
+      if (!schema || !referencedTable || !referencedColumn) {
+        throw new Error("Policy review was cancelled.");
+      }
+      foreignKey = {
+        schema,
+        table: referencedTable,
+        column: referencedColumn,
+      };
+    }
+    return { action, generated, identity, foreignKey };
+  };
   const policy = await completePolicyDraft({
     draft,
-    reviewColumn: async ({ table, column }) => {
-      reviewedColumns += 1;
-      const label = `${table}.${column} (${reviewedColumns}/${totalColumns})`;
-      const action = await promptForSelection({
-        message: `${label}: how should this value be handled?`,
+    reviewColumn,
+    reviewTable: async ({ table, columns }) => {
+      if (columns.length === 1) {
+        tableSummaries.push({ table, defaulted: 0, individual: 1 });
+        return {};
+      }
+      const mode = await promptForSelection({
+        message: `${table}: how would you like to review ${formatCount(columns.length, "column")}?`,
         flags,
         options: [
           {
-            label: "Replace with synthetic data",
-            hint: "Safest default",
-            value: "REPLACE WITH SYNTHETIC",
-          },
-          {
-            label: "Pseudonymize consistently",
-            hint: "Stable links without original values",
-            value: "PSEUDONYMIZE",
-          },
-          {
-            label: "Derive a safe value",
-            value: "DERIVE",
+            label: "Use safe defaults, then review exceptions",
+            hint: "Best for larger tables",
+            value: "preset",
           },
-          { label: "Exclude this field", value: "EXCLUDE" },
           {
-            label: "Keep exactly",
-            hint: "Only for values explicitly safe to retain",
-            value: "KEEP EXACTLY",
+            label: "Review every column individually",
+            value: "individual",
           },
         ],
       });
-      if (!action) throw new Error("Policy review was cancelled.");
-      const generated = await promptForSelection({
-        message: `${label}: is this column always database-generated?`,
+      if (!mode) throw new Error("Policy review was cancelled.");
+      if (mode === "individual") {
+        tableSummaries.push({
+          table,
+          defaulted: 0,
+          individual: columns.length,
+        });
+        return {};
+      }
+      const suggested = suggestPolicyExceptionColumns(columns);
+      const exceptions = await promptForMultipleChoice({
+        message: `${table}: select columns that need individual review`,
         flags,
-        options: [
-          { label: "No", value: "NEVER" },
-          { label: "Yes", value: "ALWAYS" },
-        ],
+        options: columns.map((column) => ({ label: column, value: column })),
+        initialValues: suggested,
       });
-      if (!generated) throw new Error("Policy review was cancelled.");
-      const identity = await promptForSelection({
-        message: `${label}: is this an identity column?`,
-        flags,
-        options: [
-          { label: "No", value: "NO" },
-          { label: "Yes", value: "YES" },
-        ],
+      if (!exceptions) throw new Error("Policy review was cancelled.");
+      const tableDecisions = createSafeTablePreset(columns);
+      for (const column of exceptions) delete tableDecisions[column];
+      tableSummaries.push({
+        table,
+        defaulted: columns.length - exceptions.length,
+        individual: exceptions.length,
       });
-      if (!identity) throw new Error("Policy review was cancelled.");
-      const hasForeignKey = await promptForConfirmation(
-        `${label}: does this column reference another table?`,
-        flags,
-        { cancelValue: null },
-      );
-      if (hasForeignKey === null) {
-        throw new Error("Policy review was cancelled.");
-      }
-      let foreignKey = null;
-      if (hasForeignKey) {
-        const schema = await promptForPath({
-          message: `${label}: referenced schema`,
-          defaultValue: "public",
-          flags,
-          validate: (value) =>
-            /^[a-z][a-z0-9_]{0,62}$/u.test(value)
-              ? undefined
-              : "Use a lowercase PostgreSQL identifier.",
-        });
-        const referencedTable = await promptForPath({
-          message: `${label}: referenced table`,
-          flags,
-          validate: (value) =>
-            /^[a-z][a-z0-9_]{0,62}$/u.test(value)
-              ? undefined
-              : "Use a lowercase PostgreSQL identifier.",
-        });
-        const referencedColumn = await promptForPath({
-          message: `${label}: referenced column`,
-          flags,
-          validate: (value) =>
-            /^[a-z][a-z0-9_]{0,62}$/u.test(value)
-              ? undefined
-              : "Use a lowercase PostgreSQL identifier.",
-        });
-        if (!schema || !referencedTable || !referencedColumn) {
-          throw new Error("Policy review was cancelled.");
-        }
-        foreignKey = {
-          schema,
-          table: referencedTable,
-          column: referencedColumn,
-        };
+      if (useStyledPrompts(flags)) {
+        prompts.log.info(
+          `${table}: ${formatCount(columns.length - exceptions.length, "safe default")}; ${formatCount(exceptions.length, "exception")}.`,
+        );
       }
-      return { action, generated, identity, foreignKey };
+      return tableDecisions;
     },
   });
+  const defaultedColumns = totalColumns - individuallyReviewed;
+  const summaryLines = tableSummaries.map(
+    (summary) =>
+      `${summary.table}: ${formatCount(summary.defaulted, "safe default")}; ${formatCount(summary.individual, "individual review")}`,
+  );
+  if (useStyledPrompts(flags)) {
+    prompts.note(summaryLines.join("\n"), "Review summary");
+  } else {
+    console.log(["", "Review summary", ...summaryLines, ""].join("\n"));
+  }
   const accepted = await promptForConfirmation(
-    `Save ${formatCount(totalColumns, "reviewed column")} and activate this policy?`,
+    `Save ${formatCount(totalColumns, "classified column")} and activate this policy?`,
     flags,
   );
   if (!accepted) return false;
@@ -585,14 +746,11 @@ const reviewPolicyInteractively = async ({ state, flags }) => {
     originalSource: source,
     policy,
   });
+  const result = `${formatCount(totalColumns, "column")} classified (${formatCount(defaultedColumns, "safe default")}; ${formatCount(individuallyReviewed, "individual review")}).`;
   if (useStyledPrompts(flags)) {
-    prompts.log.success(
-      `${formatCount(totalColumns, "column")} reviewed; the policy is ready for baseline creation.`,
-    );
+    prompts.log.success(`${result} The policy is ready for baseline creation.`);
   } else {
-    console.log(
-      `Reviewed policy saved: ${formatCount(totalColumns, "column")} classified.`,
-    );
+    console.log(`Reviewed policy saved: ${result}`);
   }
   return true;
 };
@@ -632,7 +790,7 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     } else if (state.policy === "needs-review") {
       options.push({
         label: "Review the script",
-        hint: "Classify every column interactively",
+        hint: "Apply table presets and review exceptions",
         command: "policy-review",
       });
     } else {
@@ -660,6 +818,11 @@ const runGuidedHome = async ({ flags, planOptions }) => {
     });
   }
   options.push(
+    {
+      label: "Get help",
+      hint: "Create a safe, copy-ready support report",
+      command: "support",
+    },
     { label: "Show all commands", command: "help" },
     { label: "Exit", command: "exit" },
   );
@@ -797,55 +960,95 @@ const runGuidedHome = async ({ flags, planOptions }) => {
         "",
       ].join("\n"),
     );
-    const recordsDefault = await firstExistingPath([
-      "rehearsal/sanitized-data.ndjson",
-      "rehearsal/synthetic-data.ndjson",
-    ]);
-    const ledgerDefault = await firstExistingPath([
-      "rehearsal/migration-ledger.json",
-    ]);
-    flags.recordsPath = await promptForPath({
+    const discovered = await discoverBaselineInputFiles({ projectRoot });
+    const detectedLines = [
+      discovered.records.length
+        ? `Records: ${discovered.records.join(", ")}`
+        : "Records: none detected",
+      discovered.ledgers.length
+        ? `Migration ledgers: ${discovered.ledgers.join(", ")}`
+        : "Migration ledgers: none detected",
+      discovered.assetManifests.length
+        ? `Storage manifests: ${discovered.assetManifests.join(", ")}`
+        : "Storage manifests: none detected",
+      "Only paths and file structure were inspected; row values stay hidden.",
+    ];
+    if (useStyledPrompts(flags)) {
+      prompts.note(detectedLines.join("\n"), "Detected safe local inputs");
+    } else {
+      console.log(
+        ["Detected safe local inputs", ...detectedLines, ""].join("\n"),
+      );
+    }
+    flags.recordsPath = await promptForDiscoveredPath({
       message: "Sanitized NDJSON records",
-      defaultValue: recordsDefault,
+      candidates: discovered.records,
       flags,
     });
-    flags.ledgerPath = await promptForPath({
+    flags.ledgerPath = await promptForDiscoveredPath({
       message: "Migration ledger",
-      defaultValue: ledgerDefault,
+      candidates: discovered.ledgers,
       flags,
     });
-    if (selected.command === "baseline-prepare") {
-      const preparationPlan = await planBaselinePreparation({
+    try {
+      if (selected.command === "baseline-prepare") {
+        const preparationPlan = await planBaselinePreparation({
+          ...planOptions,
+          recordsPath: flags.recordsPath,
+          ledgerPath: flags.ledgerPath,
+        });
+        const preview = {
+          ...summarizeBaselinePreparation(preparationPlan, {
+            mode: "preview",
+          }),
+          nextAction:
+            "Review this schema-only summary. No file is written unless you approve below.",
+        };
+        console.log(`\n${renderBaselinePreparation(preview, flags)}\n`);
+        const accepted = await promptForConfirmation(
+          `Create the REVIEW REQUIRED draft at ${preview.destination}?`,
+          flags,
+        );
+        if (!accepted) {
+          console.log("No changes made.");
+          return "refresh";
+        }
+        flags.preparationPlan = preparationPlan;
+        flags.write = true;
+        return "baseline prepare";
+      }
+      flags.assetsPath = await promptForDiscoveredPath({
+        message: "Storage assets",
+        candidates: discovered.assetManifests,
+        optional: true,
+        flags,
+      });
+      const inspection = await inspectBaselineInputFiles({
         ...planOptions,
         recordsPath: flags.recordsPath,
         ledgerPath: flags.ledgerPath,
+        assetsPath: flags.assetsPath,
       });
-      const preview = {
-        ...summarizeBaselinePreparation(preparationPlan, {
-          mode: "preview",
-        }),
-        nextAction:
-          "Review this schema-only summary. No file is written unless you approve below.",
-      };
-      console.log(`\n${renderBaselinePreparation(preview, flags)}\n`);
+      console.log(`\n${renderBaselineInputInspection(inspection, flags)}\n`);
       const accepted = await promptForConfirmation(
-        `Create the REVIEW REQUIRED draft at ${preview.destination}?`,
+        "Create and activate this immutable local baseline?",
         flags,
       );
       if (!accepted) {
         console.log("No changes made.");
         return "refresh";
       }
-      flags.preparationPlan = preparationPlan;
-      flags.write = true;
-      return "baseline prepare";
+      return "baseline create";
+    } catch (error) {
+      const message = redactDiagnosticValue(String(error?.message ?? error));
+      if (useStyledPrompts(flags)) {
+        prompts.cancel("These baseline inputs need attention.");
+        prompts.note(message, "How to continue");
+      } else {
+        console.log(`\nBASELINE INPUTS NEED ATTENTION\n${message}\n`);
+      }
+      return "refresh";
     }
-    flags.assetsPath = await promptForPath({
-      message: "Storage asset manifest (optional)",
-      optional: true,
-      flags,
-    });
-    return "baseline create";
   }
   if (selected.command !== "setup-write") return selected.command;
 
@@ -1314,6 +1517,56 @@ const renderBaselinePreparation = (result, flags = {}) =>
     result.nextAction,
   ].join("\n");
 
+const renderBaselineInputInspection = (result, flags = {}) =>
+  [
+    "BASELINE INPUTS — READY",
+    `Records: ${formatCount(result.rowCount, "row")} across ${formatCount(result.tables.length, "table")} from ${result.recordsPath}`,
+    `Migrations: ${formatCount(result.migrationCount, "migration")} through ${result.migrationCutoff} from ${result.ledgerPath}`,
+    result.assetsPath
+      ? `Storage: ${formatCount(result.assetCount, "asset")} from ${result.assetsPath}`
+      : "Storage: no asset manifest selected",
+    "",
+    "Detected tables (values are never printed)",
+    ...result.tables.map(
+      (table) =>
+        `  ${terminalStyle(flags, "36", "→")} ${table.name}: ${formatCount(table.rowCount, "row")}`,
+    ),
+    "",
+    "All inputs are project-local regular files and passed structural validation.",
+  ].join("\n");
+
+const renderSupportReport = (report) => {
+  const toolLine = (label, tool) =>
+    `${label}: ${tool.status === "available" ? tool.version : tool.status.replaceAll("_", " ")}`;
+  return [
+    "REHEARSAL SUPPORT REPORT",
+    "",
+    `Rehearsal: ${report.rehearsalVersion}`,
+    `System: ${report.system.platform} ${report.system.architecture} (${report.system.release})`,
+    `Node.js: ${report.system.node}`,
+    toolLine("npm", report.tools.npm),
+    toolLine("Supabase CLI", report.tools.supabase),
+    toolLine("Docker client", report.tools.dockerClient),
+    toolLine("Docker server", report.tools.dockerServer),
+    "",
+    `Readiness: ${report.readiness.state}`,
+    ...report.readiness.checks.map((check) =>
+      check.status === "pass"
+        ? `  ✓ ${check.label}`
+        : `  ✗ ${check.label}${check.remediation ? ` — ${check.remediation}` : ""}`,
+    ),
+    ...(report.readiness.quarantinedHostedVariableCount
+      ? [
+          `  ! ${formatCount(report.readiness.quarantinedHostedVariableCount, "ambient hosted variable")} detected and quarantined`,
+        ]
+      : []),
+    "",
+    "Privacy: no row values, credentials, project paths, migration SQL, or baseline identifiers are included.",
+    "Review this report before sharing it.",
+    `Report a reproducible issue: ${report.supportUrl}`,
+  ].join("\n");
+};
+
 const usage = () => `Usage: rehearsal <command> [options]
 
 Commands:
@@ -1323,6 +1576,7 @@ Commands:
   baseline prepare --records= --ledger= [--write] Create a fail-closed policy draft
   baseline create --records= --ledger= [--assets=] Create a baseline from safe local inputs
   doctor                     Check whether Rehearsal is safe and ready
+  support                    Print a safe, copy-ready support report
   explain                    Show the immutable execution plan
   run --dry-run              Alias the exact explain plan without mutations
   run --confirm-candidates=  Execute reset, migration, and verification locally
@@ -1365,6 +1619,12 @@ const executeCommand = async ({ command, flags, planOptions, guided }) => {
     return;
   }
   if (command === "baseline create") {
+    await inspectBaselineInputFiles({
+      ...planOptions,
+      recordsPath: flags.recordsPath,
+      ledgerPath: flags.ledgerPath,
+      assetsPath: flags.assetsPath,
+    });
     const data = await createSyntheticBaselineFromFiles({
       ...planOptions,
       recordsPath: flags.recordsPath,
@@ -1398,6 +1658,11 @@ const executeCommand = async ({ command, flags, planOptions, guided }) => {
     if (data.state !== "READY" && !guided) process.exitCode = 1;
     return;
   }
+  if (command === "support") {
+    const data = await collectRehearsalSupportReport(planOptions);
+    emit({ command, data, flags, render: renderSupportReport });
+    return;
+  }
   if (command === "explain" || (command === "run" && flags.dryRun)) {
     const data = await buildRehearsalPlan(planOptions);
     emit({ command, data, flags, render: renderPlan });