@rehearsal-db/core 0.1.0-beta.15 → 0.1.0-beta.16

package/dist/src/cli/inspection_command_handlers.d.mts

@@ -0,0 +1,3 @@
+/** Read-only readiness, support, planning, and inspection command handlers. */
+import type { CommandDefinition } from "./command_contract.mjs";
+export declare const createInspectionCommandHandlers: () => readonly CommandDefinition[];

package/dist/src/cli/inspection_command_handlers.mjs

@@ -0,0 +1,79 @@
+/** Read-only readiness, support, planning, and inspection command handlers. */
+import { collectRehearsalSupportReport } from "../project/support_report.mjs";
+import { inspectRehearsalBaseline, inspectRehearsalMigrations, } from "../runtime/plan.mjs";
+import { buildRuntimeStackPlan, runRuntimeStackDoctor, topologyCandidateSummary, } from "./runtime_commands.mjs";
+import { renderBaseline, renderCandidates, renderDoctor, renderMigrations, renderPlan, renderSupportReport, } from "./renderers.mjs";
+import { exactCommands, renderedCommand } from "./command_contract.mjs";
+export const createInspectionCommandHandlers = () => [
+    exactCommands("doctor", ["doctor"], async ({ guided, flags, planOptions }) => {
+        const data = await runRuntimeStackDoctor(planOptions);
+        return renderedCommand({
+            data,
+            render: (result, verbosity) => renderDoctor(result, verbosity),
+            status: data.state === "READY" ? "success" : "not_ready",
+            ...(data.state !== "READY" && !guided ? { exitCode: 1 } : {}),
+        });
+    }),
+    exactCommands("support", ["support"], async ({ planOptions }) => {
+        const data = await collectRehearsalSupportReport(planOptions, {
+            runDoctor: async (options) => {
+                const report = await runRuntimeStackDoctor(options);
+                const targetAliases = new Map();
+                const aliasFor = (name) => {
+                    if (!targetAliases.has(name)) {
+                        targetAliases.set(name, `runtime-${targetAliases.size + 1}`);
+                    }
+                    return targetAliases.get(name);
+                };
+                return {
+                    ...report,
+                    checks: report.checks.map((check) => {
+                        const separator = check.id.indexOf(":");
+                        if (separator === -1)
+                            return check;
+                        const target = check.id.slice(0, separator);
+                        const alias = aliasFor(target);
+                        return {
+                            ...check,
+                            id: `${alias}:${check.id.slice(separator + 1)}`,
+                            label: check.label.replace(`${target}:`, `${alias}:`),
+                        };
+                    }),
+                };
+            },
+        });
+        return renderedCommand({
+            data,
+            render: (result) => renderSupportReport(result),
+        });
+    }),
+    {
+        id: "explain",
+        matches: ({ command, flags }) => command === "explain" || (command === "run" && flags.dryRun),
+        handle: async ({ planOptions }) => {
+            const data = await buildRuntimeStackPlan(planOptions);
+            return renderedCommand({
+                data,
+                render: (result, verbosity) => renderPlan(result, verbosity),
+            });
+        },
+    },
+    exactCommands("inspect-baseline", ["inspect baseline"], async ({ planOptions }) => {
+        const data = await inspectRehearsalBaseline(planOptions);
+        return renderedCommand({ data, render: renderBaseline });
+    }),
+    exactCommands("inspect-migrations", ["inspect migrations"], async ({ planOptions }) => {
+        const data = await inspectRehearsalMigrations(planOptions);
+        return renderedCommand({
+            data,
+            render: (result, verbosity) => renderMigrations(result, verbosity),
+        });
+    }),
+    exactCommands("candidates", ["candidates"], async ({ planOptions }) => {
+        const { topology: _topology, ...data } = await topologyCandidateSummary(planOptions);
+        return renderedCommand({
+            data,
+            render: (result, verbosity) => renderCandidates(result, verbosity),
+        });
+    }),
+];

package/dist/src/cli/project_command_handlers.d.mts

@@ -0,0 +1,11 @@
+/** Project setup, baseline creation, privacy-key, and cleanup command handlers. */
+import type { CommandDefinition } from "./command_contract.mjs";
+import type { createProjectCommands } from "./project_commands.mjs";
+type ProjectCommands = ReturnType<typeof createProjectCommands>;
+export declare const createProjectCommandHandlers: ({ projectRoot, runSetup, runBaselinePreparation, runCleanup, }: {
+    projectRoot: string;
+    runSetup: ProjectCommands["runSetup"];
+    runBaselinePreparation: ProjectCommands["runBaselinePreparation"];
+    runCleanup: ProjectCommands["runCleanup"];
+}) => readonly CommandDefinition[];
+export {};

package/dist/src/cli/project_command_handlers.mjs

@@ -0,0 +1,92 @@
+/** Project setup, baseline creation, privacy-key, and cleanup command handlers. */
+import { relative } from "node:path";
+import { createSyntheticBaselineFromFiles } from "../baseline/builder.mjs";
+import { inspectBaselineInputFiles } from "../baseline/preparation.mjs";
+import { createPrivacyKey } from "../baseline/privacy_engine.mjs";
+import { formatCount } from "../shared/human_output.mjs";
+import { runRehearsalInit } from "./init_command.mjs";
+import { loadPreparationContext } from "./source_commands.mjs";
+import { renderBaselinePreparation, renderCleanup, renderInit, renderSetup, } from "./renderers.mjs";
+import { exactCommands, renderedCommand } from "./command_contract.mjs";
+export const createProjectCommandHandlers = ({ projectRoot, runSetup, runBaselinePreparation, runCleanup, }) => [
+    exactCommands("setup", ["setup"], async ({ flags, planOptions, state }) => {
+        const data = await runSetup({ flags, planOptions, session: state });
+        return renderedCommand({
+            data,
+            render: () => renderSetup(data),
+        });
+    }),
+    exactCommands("init", ["init"], async ({ flags }) => {
+        const data = await runRehearsalInit({ projectRoot, flags });
+        return renderedCommand({
+            data,
+            render: (result) => renderInit(result),
+        });
+    }),
+    exactCommands("baseline-prepare", ["baseline prepare"], async ({ flags, planOptions, state }) => {
+        const data = await runBaselinePreparation({
+            flags,
+            planOptions,
+            session: state,
+        });
+        return renderedCommand({
+            data,
+            render: (result) => renderBaselinePreparation(result, flags),
+        });
+    }),
+    exactCommands("baseline-create", ["baseline create"], async ({ flags, planOptions }) => {
+        if (!flags.recordsPath || !flags.ledgerPath) {
+            throw new Error("baseline create requires --records and --ledger input paths.");
+        }
+        const baselineInput = {
+            ...planOptions,
+            recordsPath: flags.recordsPath,
+            ledgerPath: flags.ledgerPath,
+            ...(flags.assetsPath === undefined
+                ? {}
+                : { assetsPath: flags.assetsPath }),
+        };
+        await inspectBaselineInputFiles(baselineInput);
+        const data = await createSyntheticBaselineFromFiles(baselineInput);
+        return renderedCommand({
+            data,
+            render: (baseline) => [
+                `Activated synthetic baseline ${baseline.generationId}: ${formatCount(baseline.rowCount, "row")} across ${formatCount(baseline.tableCount, "table")}; ${formatCount(baseline.migrationCount, "migration")} through ${baseline.migrationCutoff}.`,
+                "",
+                flags.guided
+                    ? "Next: choose Run a rehearsal when you are ready."
+                    : "Next: run rehearsal doctor to check readiness.",
+            ].join("\n"),
+        });
+    }),
+    exactCommands("privacy-key", ["privacy key"], async ({ flags, planOptions }) => {
+        const { loaded } = await loadPreparationContext(planOptions);
+        if (!loaded.paths.privacyKey) {
+            throw new Error("No config.preparation.privacyKey is configured.");
+        }
+        const privacyKeyPath = loaded.paths.privacyKey;
+        const data = flags.write
+            ? {
+                mode: "written",
+                path: relative(loaded.projectRoot, privacyKeyPath),
+                ...(await createPrivacyKey(privacyKeyPath)),
+            }
+            : {
+                mode: "preview",
+                path: relative(loaded.projectRoot, privacyKeyPath),
+            };
+        return renderedCommand({
+            data,
+            render: (result) => result.mode === "preview"
+                ? `PRIVACY KEY — PREVIEW\n\nWould create ${result.path} with owner-only permissions.\nNothing was written. Rerun with --write after reviewing the path.`
+                : `Created owner-only privacy key at ${result.path}.\nFingerprint: ${result.fingerprint}\nThe key is excluded from source control and must not be shared.`,
+        });
+    }),
+    exactCommands("cleanup", ["cleanup"], async ({ flags, planOptions, state }) => {
+        const data = await runCleanup({ flags, planOptions, session: state });
+        return renderedCommand({
+            data,
+            render: () => renderCleanup(data),
+        });
+    }),
+];

package/dist/src/cli/project_commands.d.mts

@@ -3,6 +3,7 @@ import { summarizeBaselinePreparation } from "../baseline/preparation.mjs";
 import type { RehearsalConfigPathOptions } from "../project/configuration.mjs";
 import type { RehearsalCleanupPlan } from "../runtime/cleanup.mjs";
 import type { RehearsalCliFlags } from "./arguments.mjs";
+import type { CliSessionState } from "./command_contract.mjs";
 type CleanupStackPlan = Readonly<{
     digest: string;
     targets: readonly Readonly<{
@@ -20,6 +21,7 @@ type RunManager = (input: {
 interface ProjectCommandInput {
     readonly flags: RehearsalCliFlags;
     readonly planOptions: RehearsalConfigPathOptions;
+    readonly session?: CliSessionState;
 }
 export declare const createProjectCommands: ({ projectRoot, runManager, }: {
     projectRoot: string;
@@ -147,11 +149,11 @@ export declare const createProjectCommands: ({ projectRoot, runManager, }: {
                 runtimeAdapter: string | null;
             }>;
         }>;
-        plan: import("../identity/claim.mjs").IdentityClaimPlan;
+        plan: import("../identity/claim_contract.mjs").IdentityClaimPlan;
     }>;
     planRuntimeStackCleanup: ({ flags, planOptions, }: ProjectCommandInput) => Promise<RehearsalCleanupPlan | CleanupStackPlan>;
-    runBaselinePreparation: ({ flags, planOptions, }: ProjectCommandInput) => Promise<ReturnType<typeof summarizeBaselinePreparation>>;
-    runCleanup: ({ flags, planOptions, }: ProjectCommandInput) => Promise<unknown>;
-    runSetup: ({ flags, planOptions, }: ProjectCommandInput) => Promise<unknown>;
+    runBaselinePreparation: ({ flags, planOptions, session, }: ProjectCommandInput) => Promise<ReturnType<typeof summarizeBaselinePreparation>>;
+    runCleanup: ({ flags, planOptions, session, }: ProjectCommandInput) => Promise<unknown>;
+    runSetup: ({ flags, planOptions, session, }: ProjectCommandInput) => Promise<unknown>;
 }>;
 export {};

package/dist/src/cli/project_commands.mjs

@@ -10,14 +10,14 @@ import { runRehearsalDoctor } from "../runtime/plan.mjs";
 import { loadRuntimeTopology } from "../runtime/topology.mjs";
 const isCleanupStackPlan = (plan) => "targets" in plan;
 export const createProjectCommands = ({ projectRoot, runManager, }) => {
-    const runSetup = async ({ flags, planOptions, }) => {
+    const runSetup = async ({ flags, planOptions, session, }) => {
         const setupTarget = flags.target === "supabase" || flags.target === "postgresql"
             ? flags.target
             : undefined;
         if (flags.target !== undefined && setupTarget === undefined) {
             throw new Error("--target must be supabase or postgresql.");
         }
-        const plan = flags.setupPlan ??
+        const plan = session?.setupPlan ??
             (await planRehearsalSetup({
                 projectRoot,
                 ...(planOptions.configPath === undefined
@@ -49,11 +49,11 @@ export const createProjectCommands = ({ projectRoot, runManager, }) => {
             ].join("\n"),
         };
     };
-    const runBaselinePreparation = async ({ flags, planOptions, }) => {
+    const runBaselinePreparation = async ({ flags, planOptions, session, }) => {
         if (!flags.recordsPath || !flags.ledgerPath) {
             throw new Error("baseline prepare requires --records and --ledger input paths.");
         }
-        const plan = flags.preparationPlan ??
+        const plan = session?.preparationPlan ??
             (await planBaselinePreparation({
                 ...planOptions,
                 recordsPath: flags.recordsPath,
@@ -98,8 +98,8 @@ export const createProjectCommands = ({ projectRoot, runManager, }) => {
             targets,
         };
     };
-    const runCleanup = async ({ flags, planOptions, }) => {
-        const plan = flags.cleanupPlan ??
+    const runCleanup = async ({ flags, planOptions, session, }) => {
+        const plan = session?.cleanupPlan ??
             (await planRuntimeStackCleanup({ flags, planOptions }));
         if (!flags.write)
             return { mode: "preview", plan };

package/dist/src/cli/rehearsal.d.mts

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 /**
- * Purpose: Run the versioned, project-configured Rehearsal developer CLI for
- * initialization, readiness, planning, inspection, and verified local execution.
+ * Purpose: Parse one CLI request, protect project mutations, and delegate to
+ * the typed command registry shared by scripted and guided flows.
  * Run: `npm run rehearsal -- doctor` or `npm run rehearsal -- explain`.
  */
 export {};