@rainy-updates/cli 0.5.7 → 0.6.0

package/dist/commands/dashboard/runner.js

@@ -1,47 +1,77 @@
-import React from "react";
-import { render } from "ink";
-import { loadConfig } from "../../config/loader.js";
-import { DashboardTUI } from "../../ui/dashboard/DashboardTUI.js";
-// We'll need to load initial state or data before or during the render
-import { check } from "../../core/check.js";
-export async function runDashboard(options) {
-    // Load configuration
-    const resolvedConfig = await loadConfig(options.cwd);
-    // Create an initial check result. In a real scenario, this could run
-    // progressively in the TUI, but for simplicity we fetch initial data first.
-    const checkResult = await check({
+import { createDecisionPlan, defaultDecisionPlanPath, filterReviewItemsByFocus, writeDecisionPlan, } from "../../core/decision-plan.js";
+import { buildReviewResult, renderReviewResult } from "../../core/review-model.js";
+import { applySelectedUpdates } from "../../core/upgrade.js";
+import { runVerification } from "../../core/verification.js";
+import { runTui } from "../../ui/tui.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
+export async function runDashboard(options, prebuiltReview) {
+    const review = prebuiltReview ?? (await buildReviewResult({
         ...options,
-        // We do not want `check` to exit or log heavily here, the UI will take over.
-        logLevel: "error",
-    });
-    // Render the interactive Ink Dashboard
-    const { waitUntilExit } = render(React.createElement(DashboardTUI, {
-        options,
-        initialResult: checkResult,
+        interactive: false,
     }));
-    await waitUntilExit();
-    const finalStore = await import("../../ui/dashboard/store.js");
-    const finalState = finalStore.getStore()?.getState();
-    if (finalState?.shouldApply) {
-        process.stderr.write("[dashboard] Applying updates...\n");
-        const { applySelectedUpdates } = await import("../../core/upgrade.js");
-        const { detectPackageManager } = await import("../../pm/detect.js");
-        const { installDependencies } = await import("../../pm/install.js");
+    const visibleItems = filterReviewItemsByFocus(review.items, options.focus);
+    const selectedItems = await selectDashboardItems(options, visibleItems);
+    const decisionPlan = createDecisionPlan({
+        review,
+        selectedItems,
+        sourceCommand: "dashboard",
+        mode: options.mode,
+        focus: options.focus,
+    });
+    const decisionPlanFile = options.decisionPlanFile ?? defaultDecisionPlanPath(options.cwd);
+    await writeDecisionPlan(decisionPlanFile, decisionPlan);
+    review.decisionPlan = decisionPlan;
+    review.summary.decisionPlan = decisionPlanFile;
+    review.summary.interactiveSurface = "dashboard";
+    review.summary.queueFocus = options.focus;
+    review.summary.suggestedCommand =
+        options.mode === "upgrade" || options.applySelected
+            ? `rup upgrade --from-plan ${decisionPlanFile}`
+            : `rup upgrade --from-plan ${decisionPlanFile}`;
+    if ((options.mode === "upgrade" || options.applySelected) && selectedItems.length > 0) {
         await applySelectedUpdates({
             ...options,
-            install: false, // We handle installation explicitly below
+            install: false,
             packageManager: "auto",
-            sync: true,
-            lockfileMode: options.lockfileMode || "preserve",
-        }, finalState.updates);
-        // Install using the correct package manager if desired
-        const detected = await detectPackageManager(options.cwd);
-        await installDependencies(options.cwd, "auto", detected);
-        process.stderr.write("[dashboard] Successfully applied updates and installed dependencies.\n");
+            sync: options.workspace,
+        }, selectedItems.map((item) => item.update));
+        if (options.verify !== "none") {
+            const verification = await runVerification({
+                cwd: options.cwd,
+                verify: options.verify,
+                testCommand: options.testCommand,
+                verificationReportFile: options.verificationReportFile,
+                packageManager: "auto",
+            });
+            if (!verification.passed) {
+                review.errors.push(...verification.checks
+                    .filter((check) => !check.passed)
+                    .map((check) => `Verification failed for ${check.name}: ${check.error ?? check.command}`));
+            }
+        }
     }
+    writeStdout(renderReviewResult({
+        ...review,
+        items: selectedItems,
+        updates: selectedItems.map((item) => item.update),
+    }) + "\n");
+    writeStderr(`[dashboard] decision plan written to ${decisionPlanFile}\n`);
     return {
         completed: true,
-        errors: [],
-        warnings: [],
+        errors: review.errors,
+        warnings: review.warnings,
+        selectedUpdates: selectedItems.length,
+        decisionPlanFile,
     };
 }
+async function selectDashboardItems(options, visibleItems) {
+    if (visibleItems.length === 0) {
+        return [];
+    }
+    return runTui(visibleItems, {
+        title: options.mode === "upgrade"
+            ? "Rainy Dashboard: Upgrade Queue"
+            : "Rainy Dashboard: Review Queue",
+        subtitle: `focus=${options.focus}  mode=${options.mode}  Enter confirms the selected decision set`,
+    });
+}

package/dist/commands/doctor/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseDoctorArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         target: "latest",
         filter: undefined,
         reject: undefined,
@@ -41,6 +41,11 @@ export function parseDoctorArgs(args) {
         interactive: false,
         showImpact: true,
         showHomepage: true,
+        decisionPlanFile: undefined,
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
         verdictOnly: false,
         includeChangelog: false,
         agentReport: false,
@@ -79,8 +84,8 @@ export function parseDoctorArgs(args) {
         if (current === "--json-file")
             throw new Error("Missing value for --json-file");
         if (current === "--help" || current === "-h") {
-            process.stdout.write(DOCTOR_HELP);
-            process.exit(0);
+            writeStdout(DOCTOR_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown doctor option: ${current}`);

package/dist/commands/doctor/runner.js

@@ -1,14 +1,14 @@
-import process from "node:process";
 import { buildReviewResult, createDoctorResult, renderDoctorAgentReport, renderDoctorResult, } from "../../core/review-model.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runDoctor(options) {
     const review = await buildReviewResult(options);
     const doctor = createDoctorResult(review);
     const output = options.agentReport
         ? renderDoctorAgentReport(doctor)
         : renderDoctorResult(doctor, options.verdictOnly);
-    process.stdout.write(output + "\n");
+    writeStdout(output + "\n");
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(doctor, 2) + "\n");
     }

package/dist/commands/ga/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseGaArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         workspace: false,
         jsonFile: undefined,
     };
@@ -28,8 +28,8 @@ export function parseGaArgs(args) {
         if (current === "--json-file")
             throw new Error("Missing value for --json-file");
         if (current === "--help" || current === "-h") {
-            process.stdout.write(GA_HELP);
-            process.exit(0);
+            writeStdout(GA_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown ga option: ${current}`);

package/dist/commands/ga/runner.js

@@ -1,11 +1,10 @@
-import { promises as fs } from "node:fs";
 import path from "node:path";
-import process from "node:process";
 import { VersionCache } from "../../cache/cache.js";
 import { detectPackageManager } from "../../pm/detect.js";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runGa(options) {
     const packageManager = await detectPackageManager(options.cwd);
     const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
@@ -15,8 +14,8 @@ export async function runGa(options) {
         name: "package-manager",
         status: packageManager === "unknown" ? "warn" : "pass",
         detail: packageManager === "unknown"
-            ? "No supported lockfile was detected. npm-compatible execution is still possible."
-            : `Detected package manager: ${packageManager}.`,
+            ? "No supported lockfile was detected. Rainy can still run, but runtime/package verification will fall back to generic defaults."
+            : `Detected package manager: ${packageManager}. Runtime and verification can align with this package ecosystem, including Bun.`,
     });
     checks.push({
         name: "workspace-discovery",
@@ -40,6 +39,14 @@ export async function runGa(options) {
             ? "Built CLI entrypoint exists in dist/bin/cli.js."
             : "Built CLI entrypoint is missing; run the build before publishing a release artifact.",
     });
+    const compiledBinaryExists = await fileExists(path.resolve(options.cwd, "dist/rup"));
+    checks.push({
+        name: "runtime-artifacts",
+        status: compiledBinaryExists ? "pass" : "warn",
+        detail: compiledBinaryExists
+            ? "Compiled Bun runtime artifact exists in dist/rup."
+            : "Compiled Bun runtime artifact is missing; run bun run build:exe before publishing Bun-first release artifacts.",
+    });
     checks.push({
         name: "benchmark-gates",
         status: (await fileExists(path.resolve(options.cwd, "scripts/perf-smoke.mjs"))) &&
@@ -68,7 +75,7 @@ export async function runGa(options) {
         warnings,
         errors,
     };
-    process.stdout.write(renderGaResult(result) + "\n");
+    writeStdout(renderGaResult(result) + "\n");
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
     }
@@ -120,8 +127,7 @@ async function detectLockfile(cwd) {
 }
 async function fileExists(filePath) {
     try {
-        await fs.access(filePath);
-        return true;
+        return await Bun.file(filePath).exists();
     }
     catch {
         return false;

package/dist/commands/health/parser.js

@@ -1,8 +1,8 @@
 import path from "node:path";
-import process from "node:process";
+import { getRuntimeCwd } from "../../utils/runtime.js";
 export function parseHealthArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         workspace: false,
         staleDays: 365,
         includeDeprecated: true,

package/dist/commands/licenses/runner.js

@@ -1,9 +1,9 @@
-import process from "node:process";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { readManifest, collectDependencies, } from "../../parsers/package-json.js";
 import { asyncPool } from "../../utils/async-pool.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 import { generateSbom } from "./sbom.js";
 /**
  * Entry point for `rup licenses`. Lazy-loaded by cli.ts.
@@ -63,17 +63,17 @@ export async function runLicenses(options) {
     }
     result.totalViolations = result.violations.length;
     // Render
-    process.stdout.write(renderLicenseTable(result) + "\n");
+    writeStdout(renderLicenseTable(result) + "\n");
     // SBOM output
     if (options.sbomFile) {
         const sbom = generateSbom(result.packages, options.cwd);
         await writeFileAtomic(options.sbomFile, stableStringify(sbom, 2) + "\n");
-        process.stderr.write(`[licenses] SBOM written to ${options.sbomFile}\n`);
+        writeStderr(`[licenses] SBOM written to ${options.sbomFile}\n`);
     }
     // JSON output
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
-        process.stderr.write(`[licenses] JSON report written to ${options.jsonFile}\n`);
+        writeStderr(`[licenses] JSON report written to ${options.jsonFile}\n`);
     }
     return result;
 }

package/dist/commands/resolve/runner.js

@@ -1,8 +1,8 @@
-import process from "node:process";
 import { buildPeerGraph } from "./graph/builder.js";
 import { resolvePeerConflicts } from "./graph/resolver.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 /**
  * Entry point for `rup resolve`. Lazy-loaded by cli.ts.
  *
@@ -26,7 +26,7 @@ export async function runResolve(options) {
     if (options.afterUpdate) {
         versionOverrides = await fetchProposedVersions(options);
         if (versionOverrides.size === 0 && !options.silent) {
-            process.stderr.write("[resolve] No pending updates found — checking current state.\n");
+            writeStderr("[resolve] No pending updates found — checking current state.\n");
         }
     }
     let graph;
@@ -42,12 +42,12 @@ export async function runResolve(options) {
     result.errorConflicts = conflicts.filter((c) => c.severity === "error").length;
     result.warningConflicts = conflicts.filter((c) => c.severity === "warning").length;
     if (!options.silent) {
-        process.stdout.write(renderConflictsTable(result, options) + "\n");
+        writeStdout(renderConflictsTable(result, options) + "\n");
     }
     if (options.jsonFile) {
         await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
         if (!options.silent) {
-            process.stderr.write(`[resolve] JSON report written to ${options.jsonFile}\n`);
+            writeStderr(`[resolve] JSON report written to ${options.jsonFile}\n`);
         }
     }
     return result;
@@ -100,6 +100,11 @@ async function fetchProposedVersions(options) {
             interactive: false,
             showImpact: false,
             showHomepage: false,
+            decisionPlanFile: undefined,
+            verify: "none",
+            testCommand: undefined,
+            verificationReportFile: undefined,
+            ciGate: "check",
         });
         for (const update of checkResult.updates ?? []) {
             overrides.set(update.name, update.toVersionResolved);

package/dist/commands/review/parser.js

@@ -1,9 +1,9 @@
 import path from "node:path";
-import process from "node:process";
 import { ensureRiskLevel } from "../../core/options.js";
+import { exitProcess, getRuntimeCwd, writeStdout, } from "../../utils/runtime.js";
 export function parseReviewArgs(args) {
     const options = {
-        cwd: process.cwd(),
+        cwd: getRuntimeCwd(),
         target: "latest",
         filter: undefined,
         reject: undefined,
@@ -47,6 +47,12 @@ export function parseReviewArgs(args) {
         diff: undefined,
         applySelected: false,
         showChangelog: false,
+        decisionPlanFile: undefined,
+        queueFocus: "all",
+        verify: "none",
+        testCommand: undefined,
+        verificationReportFile: undefined,
+        ciGate: "check",
     };
     for (let i = 0; i < args.length; i += 1) {
         const current = args[i];
@@ -94,6 +100,41 @@ export function parseReviewArgs(args) {
             options.applySelected = true;
             continue;
         }
+        if (current === "--plan-file" && next) {
+            options.decisionPlanFile = path.resolve(options.cwd, next);
+            i += 1;
+            continue;
+        }
+        if (current === "--plan-file")
+            throw new Error("Missing value for --plan-file");
+        if (current === "--verify" && next) {
+            if (next === "none" ||
+                next === "install" ||
+                next === "test" ||
+                next === "install,test") {
+                options.verify = next;
+                i += 1;
+                continue;
+            }
+            throw new Error("--verify must be none, install, test or install,test");
+        }
+        if (current === "--verify")
+            throw new Error("Missing value for --verify");
+        if (current === "--test-command" && next) {
+            options.testCommand = next;
+            i += 1;
+            continue;
+        }
+        if (current === "--test-command")
+            throw new Error("Missing value for --test-command");
+        if (current === "--verification-report-file" && next) {
+            options.verificationReportFile = path.resolve(options.cwd, next);
+            i += 1;
+            continue;
+        }
+        if (current === "--verification-report-file") {
+            throw new Error("Missing value for --verification-report-file");
+        }
         if (current === "--show-changelog") {
             options.showChangelog = true;
             continue;
@@ -148,13 +189,22 @@ export function parseReviewArgs(args) {
             throw new Error("Missing value for --registry-retries");
         }
         if (current === "--help" || current === "-h") {
-            process.stdout.write(REVIEW_HELP);
-            process.exit(0);
+            writeStdout(REVIEW_HELP);
+            exitProcess(0);
         }
         if (current.startsWith("-"))
             throw new Error(`Unknown review option: ${current}`);
         throw new Error(`Unexpected review argument: ${current}`);
     }
+    if (options.securityOnly) {
+        options.queueFocus = "security";
+    }
+    else if (options.risk === "critical" || options.risk === "high") {
+        options.queueFocus = "risk";
+    }
+    else if (options.diff === "major") {
+        options.queueFocus = "major";
+    }
     return options;
 }
 const REVIEW_HELP = `
@@ -169,6 +219,9 @@ Options:
   --risk <level>          Minimum risk: critical, high, medium, low
   --diff <level>          Filter by patch, minor, major, latest
   --apply-selected        Apply all filtered updates after review
+  --plan-file <path>      Write the selected decision set to a reusable plan file
+  --verify <mode>         Run post-apply verification: none, install, test, install,test
+  --test-command <cmd>    Override the command used for test verification
   --show-changelog        Fetch release notes summaries for review output
   --workspace             Scan all workspace packages
   --policy-file <path>    Load policy overrides

package/dist/commands/review/runner.js

@@ -1,16 +1,42 @@
-import process from "node:process";
-import { runTui } from "../../ui/tui.js";
 import { buildReviewResult, renderReviewResult } from "../../core/review-model.js";
 import { applySelectedUpdates } from "../../core/upgrade.js";
+import { createDecisionPlan, writeDecisionPlan } from "../../core/decision-plan.js";
 import { stableStringify } from "../../utils/stable-json.js";
 import { writeFileAtomic } from "../../utils/io.js";
+import { writeStdout } from "../../utils/runtime.js";
 export async function runReview(options) {
     const review = await buildReviewResult(options);
-    let selectedItems = review.items;
     if (options.interactive && review.updates.length > 0) {
-        selectedItems = await runTui(review.items);
+        const { runDashboard } = await import("../dashboard/runner.js");
+        const dashboard = await runDashboard({
+            ...options,
+            mode: options.applySelected ? "upgrade" : "review",
+            focus: options.queueFocus ?? "all",
+            applySelected: options.applySelected,
+        }, review);
+        review.summary.decisionPlan = dashboard.decisionPlanFile;
+        review.summary.interactiveSurface = "dashboard";
+        review.summary.queueFocus = options.queueFocus ?? "all";
+        if (options.jsonFile) {
+            await writeFileAtomic(options.jsonFile, stableStringify(review, 2) + "\n");
+        }
+        return review;
     }
+    let selectedItems = review.items;
     const selectedUpdates = selectedItems.map((item) => item.update);
+    if (options.decisionPlanFile) {
+        const decisionPlan = createDecisionPlan({
+            review,
+            selectedItems,
+            sourceCommand: "review",
+            mode: options.applySelected ? "upgrade" : "review",
+            focus: options.queueFocus ?? "all",
+        });
+        const decisionPlanFile = options.decisionPlanFile;
+        await writeDecisionPlan(decisionPlanFile, decisionPlan);
+        review.decisionPlan = decisionPlan;
+        review.summary.decisionPlan = decisionPlanFile;
+    }
     if (options.applySelected && selectedUpdates.length > 0) {
         await applySelectedUpdates({
             ...options,
@@ -19,7 +45,7 @@ export async function runReview(options) {
             sync: false,
         }, selectedUpdates);
     }
-    process.stdout.write(renderReviewResult({
+    writeStdout(renderReviewResult({
         ...review,
         items: selectedItems,
         updates: selectedUpdates,

package/dist/commands/snapshot/runner.js

@@ -1,6 +1,6 @@
-import process from "node:process";
 import { discoverPackageDirs } from "../../workspace/discover.js";
 import { SnapshotStore, captureState, restoreState, diffManifests, } from "./store.js";
+import { writeStderr, writeStdout } from "../../utils/runtime.js";
 /**
  * Entry point for `rup snapshot`. Lazy-loaded by cli.ts.
  *
@@ -27,7 +27,7 @@ export async function runSnapshot(options) {
             const entry = await store.saveSnapshot(manifests, lockfileHashes, label);
             result.snapshotId = entry.id;
             result.label = entry.label;
-            process.stdout.write(`✔ Snapshot saved: ${entry.label} (${entry.id})\n`);
+            writeStdout(`✔ Snapshot saved: ${entry.label} (${entry.id})\n`);
             break;
         }
         // ─ list ──────────────────────────────────────────────────────────────────
@@ -39,20 +39,20 @@ export async function runSnapshot(options) {
                 createdAt: new Date(e.createdAt).toISOString(),
             }));
             if (entries.length === 0) {
-                process.stdout.write("No snapshots saved yet. Use `rup snapshot save` to create one.\n");
+                writeStdout("No snapshots saved yet. Use `rup snapshot save` to create one.\n");
             }
             else {
-                process.stdout.write(`\n${entries.length} snapshot(s):\n\n`);
-                process.stdout.write("  " + "ID".padEnd(30) + "Label".padEnd(30) + "Created\n");
-                process.stdout.write("  " + "─".repeat(75) + "\n");
+                writeStdout(`\n${entries.length} snapshot(s):\n\n`);
+                writeStdout("  " + "ID".padEnd(30) + "Label".padEnd(30) + "Created\n");
+                writeStdout("  " + "─".repeat(75) + "\n");
                 for (const e of entries) {
-                    process.stdout.write("  " +
+                    writeStdout("  " +
                         e.id.padEnd(30) +
                         e.label.padEnd(30) +
                         new Date(e.createdAt).toLocaleString() +
                         "\n");
                 }
-                process.stdout.write("\n");
+                writeStdout("\n");
             }
             break;
         }
@@ -72,8 +72,8 @@ export async function runSnapshot(options) {
             result.snapshotId = entry.id;
             result.label = entry.label;
             const count = Object.keys(entry.manifests).length;
-            process.stdout.write(`✔ Restored ${count} package.json file(s) from snapshot "${entry.label}" (${entry.id})\n`);
-            process.stdout.write("  Re-run your package manager install to apply.\n");
+            writeStdout(`✔ Restored ${count} package.json file(s) from snapshot "${entry.label}" (${entry.id})\n`);
+            writeStdout("  Re-run your package manager install to apply.\n");
             break;
         }
         // ─ diff ──────────────────────────────────────────────────────────────────
@@ -92,23 +92,23 @@ export async function runSnapshot(options) {
             const changes = diffManifests(entry.manifests, currentManifests);
             result.diff = changes;
             if (changes.length === 0) {
-                process.stdout.write(`✔ No dependency changes since snapshot "${entry.label}"\n`);
+                writeStdout(`✔ No dependency changes since snapshot "${entry.label}"\n`);
             }
             else {
-                process.stdout.write(`\nDependency changes since snapshot "${entry.label}":\n\n`);
-                process.stdout.write("  " + "Package".padEnd(35) + "Before".padEnd(20) + "After\n");
-                process.stdout.write("  " + "─".repeat(65) + "\n");
+                writeStdout(`\nDependency changes since snapshot "${entry.label}":\n\n`);
+                writeStdout("  " + "Package".padEnd(35) + "Before".padEnd(20) + "After\n");
+                writeStdout("  " + "─".repeat(65) + "\n");
                 for (const c of changes) {
-                    process.stdout.write("  " + c.name.padEnd(35) + c.from.padEnd(20) + c.to + "\n");
+                    writeStdout("  " + c.name.padEnd(35) + c.from.padEnd(20) + c.to + "\n");
                 }
-                process.stdout.write("\n");
+                writeStdout("\n");
             }
             break;
         }
     }
     if (result.errors.length > 0) {
         for (const err of result.errors) {
-            process.stderr.write(`[snapshot] ✖ ${err}\n`);
+            writeStderr(`[snapshot] ✖ ${err}\n`);
         }
     }
     return result;

package/dist/commands/snapshot/store.d.ts

@@ -1,13 +1,4 @@
 import type { SnapshotEntry } from "../../types/index.js";
-/**
- * Lightweight SQLite-free snapshot store (uses a JSON file in the project root).
- *
- * Design goals:
- *   - No extra runtime dependencies (SQLite bindings vary by runtime)
- *   - Human-readable store file (git-committable if desired)
- *   - Atomic writes via tmp-rename to prevent corruption
- *   - Fast: entire store fits in memory for typical use (< 50 snapshots)
- */
 export declare class SnapshotStore {
     private readonly storePath;
     private entries;
@@ -20,14 +11,11 @@ export declare class SnapshotStore {
     findSnapshot(idOrLabel: string): Promise<SnapshotEntry | null>;
     deleteSnapshot(idOrLabel: string): Promise<boolean>;
 }
-/** Captures current package.json and lockfile state for a set of directories. */
 export declare function captureState(packageDirs: string[]): Promise<{
     manifests: Record<string, string>;
     lockfileHashes: Record<string, string>;
 }>;
-/** Restores package.json files from a snapshot's manifest map. */
 export declare function restoreState(entry: SnapshotEntry): Promise<void>;
-/** Computes a diff of dependency versions between two manifest snapshots. */
 export declare function diffManifests(before: Record<string, string>, after: Record<string, string>): Array<{
     name: string;
     from: string;