@rainy-updates/cli 0.5.6 → 0.5.7

package/dist/bin/dispatch.js

@@ -0,0 +1,150 @@
+import process from "node:process";
+import { check } from "../core/check.js";
+import { upgrade } from "../core/upgrade.js";
+import { warmCache } from "../core/warm-cache.js";
+import { runCi } from "../core/ci.js";
+import { initCiWorkflow } from "../core/init-ci.js";
+import { diffBaseline, saveBaseline } from "../core/baseline.js";
+export async function handleDirectCommand(parsed) {
+    if (parsed.command === "init-ci") {
+        const workflow = await initCiWorkflow(parsed.options.cwd, parsed.options.force, {
+            mode: parsed.options.mode,
+            schedule: parsed.options.schedule,
+        });
+        process.stdout.write(workflow.created
+            ? `Created CI workflow at ${workflow.path}\n`
+            : `CI workflow already exists at ${workflow.path}. Use --force to overwrite.\n`);
+        return true;
+    }
+    if (parsed.command === "baseline") {
+        if (parsed.options.action === "save") {
+            const saved = await saveBaseline(parsed.options);
+            process.stdout.write(`Saved baseline at ${saved.filePath} (${saved.entries} entries)\n`);
+            return true;
+        }
+        const diff = await diffBaseline(parsed.options);
+        const changes = diff.added.length + diff.removed.length + diff.changed.length;
+        if (changes === 0) {
+            process.stdout.write(`No baseline drift detected (${diff.filePath}).\n`);
+            return true;
+        }
+        process.stdout.write(`Baseline drift detected (${diff.filePath}).\n`);
+        if (diff.added.length > 0)
+            process.stdout.write(`Added: ${diff.added.length}\n`);
+        if (diff.removed.length > 0)
+            process.stdout.write(`Removed: ${diff.removed.length}\n`);
+        if (diff.changed.length > 0)
+            process.stdout.write(`Changed: ${diff.changed.length}\n`);
+        process.exitCode = 1;
+        return true;
+    }
+    if (parsed.command === "bisect") {
+        const { runBisect } = await import("../commands/bisect/runner.js");
+        const result = await runBisect(parsed.options);
+        process.exitCode = result.breakingVersion ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "audit") {
+        const { runAudit } = await import("../commands/audit/runner.js");
+        const result = await runAudit(parsed.options);
+        process.exitCode = result.advisories.length > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "health") {
+        const { runHealth } = await import("../commands/health/runner.js");
+        const result = await runHealth(parsed.options);
+        process.exitCode = result.totalFlagged > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "unused") {
+        const { runUnused } = await import("../commands/unused/runner.js");
+        const result = await runUnused(parsed.options);
+        process.exitCode = result.totalUnused > 0 || result.totalMissing > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "resolve") {
+        const { runResolve } = await import("../commands/resolve/runner.js");
+        const result = await runResolve(parsed.options);
+        process.exitCode = result.errorConflicts > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "licenses") {
+        const { runLicenses } = await import("../commands/licenses/runner.js");
+        const result = await runLicenses(parsed.options);
+        process.exitCode = result.totalViolations > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "snapshot") {
+        const { runSnapshot } = await import("../commands/snapshot/runner.js");
+        const result = await runSnapshot(parsed.options);
+        process.exitCode = result.errors.length > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "review") {
+        const { runReview } = await import("../commands/review/runner.js");
+        const result = await runReview(parsed.options);
+        process.exitCode =
+            result.summary.verdict === "blocked" ||
+                result.summary.verdict === "actionable" ||
+                result.summary.verdict === "review"
+                ? 1
+                : 0;
+        return true;
+    }
+    if (parsed.command === "doctor") {
+        const { runDoctor } = await import("../commands/doctor/runner.js");
+        const result = await runDoctor(parsed.options);
+        process.exitCode = result.verdict === "safe" ? 0 : 1;
+        return true;
+    }
+    if (parsed.command === "dashboard") {
+        const { runDashboard } = await import("../commands/dashboard/runner.js");
+        const result = await runDashboard(parsed.options);
+        process.exitCode = result.errors.length > 0 ? 1 : 0;
+        return true;
+    }
+    if (parsed.command === "ga") {
+        const { runGa } = await import("../commands/ga/runner.js");
+        const result = await runGa(parsed.options);
+        process.exitCode = result.ready ? 0 : 1;
+        return true;
+    }
+    if (parsed.options.interactive &&
+        (parsed.command === "check" ||
+            parsed.command === "upgrade" ||
+            parsed.command === "ci")) {
+        const { runReview } = await import("../commands/review/runner.js");
+        const result = await runReview({
+            ...parsed.options,
+            securityOnly: false,
+            risk: undefined,
+            diff: undefined,
+            applySelected: parsed.command === "upgrade",
+        });
+        process.exitCode =
+            result.summary.verdict === "safe" && result.updates.length === 0 ? 0 : 1;
+        return true;
+    }
+    return false;
+}
+export async function runPrimaryCommand(parsed) {
+    if (parsed.command === "upgrade") {
+        return upgrade(parsed.options);
+    }
+    if (parsed.command === "warm-cache") {
+        return warmCache(parsed.options);
+    }
+    if (parsed.command === "ci") {
+        return runCi(parsed.options);
+    }
+    if (parsed.options.fixPr) {
+        const upgradeOptions = {
+            ...parsed.options,
+            install: false,
+            packageManager: "auto",
+            sync: false,
+        };
+        return upgrade(upgradeOptions);
+    }
+    return check(parsed.options);
+}

package/dist/bin/help.d.ts

@@ -0,0 +1 @@
+export declare function renderHelp(command?: string): string;

package/dist/bin/help.js

@@ -0,0 +1,284 @@
+export function renderHelp(command) {
+    const isCommand = command && !command.startsWith("-");
+    if (isCommand && command === "check") {
+        return `rainy-updates check [options]
+
+Detect candidate dependency updates. This is the first step in the flow:
+  check detects
+  doctor summarizes
+  review decides
+  upgrade applies
+
+Options:
+  --workspace
+  --target patch|minor|major|latest
+  --filter <pattern>
+  --reject <pattern>
+  --dep-kinds deps,dev,optional,peer
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>
+  --cache-ttl <seconds>
+  --stream
+  --policy-file <path>
+  --offline
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
+  --no-pr-report
+  --json-file <path>
+  --github-output <path>
+  --sarif-file <path>
+  --pr-report-file <path>
+  --fail-on none|patch|minor|major|any
+  --max-updates <n>
+  --group-by none|name|scope|kind|risk
+  --group-max <n>
+  --cooldown-days <n>
+  --pr-limit <n>
+  --only-changed
+  --interactive
+  --show-impact
+  --show-links
+  --show-homepage
+  --lockfile-mode preserve|update|error
+  --log-level error|warn|info|debug
+  --ci`;
+    }
+    if (isCommand && command === "warm-cache") {
+        return `rainy-updates warm-cache [options]
+
+Pre-warm local metadata cache for faster CI checks.
+
+Options:
+  --workspace
+  --target patch|minor|major|latest
+  --filter <pattern>
+  --reject <pattern>
+  --dep-kinds deps,dev,optional,peer
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>
+  --cache-ttl <seconds>
+  --offline
+  --stream
+  --json-file <path>
+  --github-output <path>
+  --sarif-file <path>
+  --pr-report-file <path>`;
+    }
+    if (isCommand && command === "upgrade") {
+        return `rainy-updates upgrade [options]
+
+Apply an approved change set to package.json manifests.
+
+Options:
+  --workspace
+  --sync
+  --install
+  --pm auto|npm|pnpm
+  --target patch|minor|major|latest
+  --policy-file <path>
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
+  --interactive
+  --lockfile-mode preserve|update|error
+  --no-pr-report
+  --json-file <path>
+  --pr-report-file <path>`;
+    }
+    if (isCommand && command === "ci") {
+        return `rainy-updates ci [options]
+
+Run CI-oriented automation around the same lifecycle:
+  check detects
+  doctor summarizes
+  review decides
+  upgrade applies
+
+Options:
+  --workspace
+  --mode minimal|strict|enterprise
+  --group-by none|name|scope|kind|risk
+  --group-max <n>
+  --cooldown-days <n>
+  --pr-limit <n>
+  --only-changed
+  --offline
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>
+  --stream
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
+  --no-pr-report
+  --json-file <path>
+  --github-output <path>
+  --sarif-file <path>
+  --pr-report-file <path>
+  --fail-on none|patch|minor|major|any
+  --max-updates <n>
+  --lockfile-mode preserve|update|error
+  --log-level error|warn|info|debug
+  --ci`;
+    }
+    if (isCommand && command === "init-ci") {
+        return `rainy-updates init-ci [options]
+
+Create a GitHub Actions workflow template at:
+  .github/workflows/rainy-updates.yml
+
+Options:
+  --force
+  --mode minimal|strict|enterprise
+  --schedule weekly|daily|off`;
+    }
+    if (isCommand && command === "baseline") {
+        return `rainy-updates baseline [options]
+
+Save or compare dependency baseline snapshots.
+
+Options:
+  --save
+  --check
+  --file <path>
+  --workspace
+  --dep-kinds deps,dev,optional,peer
+  --ci`;
+    }
+    if (isCommand && command === "audit") {
+        return `rainy-updates audit [options]
+
+Scan dependencies for CVEs using OSV.dev and GitHub Advisory Database.
+
+Options:
+  --workspace
+  --severity critical|high|medium|low
+  --summary
+  --report table|summary|json
+  --source auto|osv|github|all
+  --fix
+  --dry-run
+  --commit
+  --pm auto|npm|pnpm|bun|yarn
+  --json-file <path>
+  --concurrency <n>
+  --registry-timeout-ms <n>`;
+    }
+    if (isCommand && command === "review") {
+        return `rainy-updates review [options]
+
+Review is the decision center of Rainy Updates.
+Use it to inspect risk, security, peer, license, and policy context before applying changes.
+
+Options:
+  --workspace
+  --interactive
+  --security-only
+  --risk critical|high|medium|low
+  --diff patch|minor|major|latest
+  --apply-selected
+  --show-changelog
+  --policy-file <path>
+  --json-file <path>
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>`;
+    }
+    if (isCommand && command === "doctor") {
+        return `rainy-updates doctor [options]
+
+Produce a fast summary verdict and point the operator to review when action is needed.
+
+Options:
+  --workspace
+  --verdict-only
+  --include-changelog
+  --json-file <path>`;
+    }
+    if (isCommand && command === "ga") {
+        return `rainy-updates ga [options]
+
+Audit release and CI readiness for Rainy Updates.
+
+Options:
+  --workspace
+  --json-file <path>
+  --cwd <path>`;
+    }
+    return `rainy-updates (rup / rainy-up) <command> [options]
+
+Commands:
+  check       Detect candidate updates
+  doctor      Summarize what matters
+  review      Decide what to do
+  upgrade     Apply the approved change set
+  dashboard   Open the interactive DevOps dashboard (Ink TUI)
+  ci          Run CI-focused orchestration
+  warm-cache  Warm local cache for fast/offline checks
+  init-ci     Scaffold GitHub Actions workflow
+  baseline    Save/check dependency baseline snapshots
+  audit       Scan dependencies for CVEs (OSV.dev + GitHub)
+  health      Detect stale/deprecated/unmaintained packages
+  bisect      Find which version of a dep introduced a failure
+  unused      Detect unused or missing npm dependencies
+  resolve     Check peer dependency conflicts (pure-TS, no subprocess)
+  licenses    Scan dependency licenses and generate SPDX SBOM
+  snapshot    Save, list, restore, and diff dependency state snapshots
+  ga          Audit GA and CI readiness for this checkout
+
+Global options:
+  --cwd <path>
+  --workspace
+  --target patch|minor|major|latest
+  --format table|json|minimal|github|metrics
+  --json-file <path>
+  --github-output <path>
+  --sarif-file <path>
+  --pr-report-file <path>
+  --policy-file <path>
+  --fail-on none|patch|minor|major|any
+  --max-updates <n>
+  --group-by none|name|scope|kind|risk
+  --group-max <n>
+  --cooldown-days <n>
+  --pr-limit <n>
+  --only-changed
+  --interactive
+  --show-impact
+  --show-links
+  --show-homepage
+  --mode minimal|strict|enterprise
+  --fix-pr
+  --fix-branch <name>
+  --fix-commit-message <text>
+  --fix-dry-run
+  --fix-pr-no-checkout
+  --fix-pr-batch-size <n>
+  --no-pr-report
+  --log-level error|warn|info|debug
+  --concurrency <n>
+  --registry-timeout-ms <n>
+  --registry-retries <n>
+  --cache-ttl <seconds>
+  --offline
+  --stream
+  --lockfile-mode preserve|update|error
+  --ci
+  --help, -h
+  --version, -v`;
+}

package/dist/commands/doctor/parser.js

@@ -43,6 +43,7 @@ export function parseDoctorArgs(args) {
         showHomepage: true,
         verdictOnly: false,
         includeChangelog: false,
+        agentReport: false,
     };
     for (let i = 0; i < args.length; i += 1) {
         const current = args[i];
@@ -66,6 +67,10 @@ export function parseDoctorArgs(args) {
             options.includeChangelog = true;
             continue;
         }
+        if (current === "--agent-report") {
+            options.agentReport = true;
+            continue;
+        }
         if (current === "--json-file" && next) {
             options.jsonFile = path.resolve(options.cwd, next);
             i += 1;
@@ -92,6 +97,7 @@ Usage:
 Options:
   --verdict-only         Print the 3-line quick verdict without counts
   --include-changelog    Include release note summaries in the aggregated review data
+  --agent-report         Print a prompt-ready remediation report for coding agents
   --workspace            Scan all workspace packages
   --json-file <path>     Write JSON doctor report to file
   --cwd <path>

package/dist/commands/doctor/runner.js

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

package/dist/core/analysis/options.d.ts

@@ -0,0 +1,6 @@
+import type { AuditOptions, CheckOptions, HealthOptions, LicenseOptions, ResolveOptions, UnusedOptions } from "../../types/index.js";
+export declare function toAuditOptions(options: CheckOptions): AuditOptions;
+export declare function toResolveOptions(options: CheckOptions): ResolveOptions;
+export declare function toHealthOptions(options: CheckOptions): HealthOptions;
+export declare function toLicenseOptions(options: CheckOptions): LicenseOptions;
+export declare function toUnusedOptions(options: CheckOptions): UnusedOptions;

package/dist/core/analysis/options.js

@@ -0,0 +1,69 @@
+export function toAuditOptions(options) {
+    return {
+        cwd: options.cwd,
+        workspace: options.workspace,
+        severity: undefined,
+        fix: false,
+        dryRun: true,
+        commit: false,
+        packageManager: "auto",
+        reportFormat: "json",
+        sourceMode: "auto",
+        jsonFile: undefined,
+        concurrency: options.concurrency,
+        registryTimeoutMs: options.registryTimeoutMs,
+        silent: true,
+    };
+}
+export function toResolveOptions(options) {
+    return {
+        cwd: options.cwd,
+        workspace: options.workspace,
+        afterUpdate: true,
+        safe: false,
+        jsonFile: undefined,
+        concurrency: options.concurrency,
+        registryTimeoutMs: options.registryTimeoutMs,
+        cacheTtlSeconds: options.cacheTtlSeconds,
+        silent: true,
+    };
+}
+export function toHealthOptions(options) {
+    return {
+        cwd: options.cwd,
+        workspace: options.workspace,
+        staleDays: 365,
+        includeDeprecated: true,
+        includeAlternatives: false,
+        reportFormat: "json",
+        jsonFile: undefined,
+        concurrency: options.concurrency,
+        registryTimeoutMs: options.registryTimeoutMs,
+    };
+}
+export function toLicenseOptions(options) {
+    return {
+        cwd: options.cwd,
+        workspace: options.workspace,
+        allow: undefined,
+        deny: undefined,
+        sbomFile: undefined,
+        jsonFile: undefined,
+        diffMode: false,
+        concurrency: options.concurrency,
+        registryTimeoutMs: options.registryTimeoutMs,
+        cacheTtlSeconds: options.cacheTtlSeconds,
+    };
+}
+export function toUnusedOptions(options) {
+    return {
+        cwd: options.cwd,
+        workspace: options.workspace,
+        srcDirs: ["src", "."],
+        includeDevDependencies: true,
+        fix: false,
+        dryRun: true,
+        jsonFile: undefined,
+        concurrency: options.concurrency,
+    };
+}

package/dist/core/analysis/review-items.d.ts

@@ -0,0 +1,4 @@
+import type { AnalysisBundle, AuditResult, PackageUpdate, ResolveResult, ReviewItem, UnusedResult } from "../../types/index.js";
+export declare function buildReviewItems(updates: PackageUpdate[], auditResult: AuditResult, resolveResult: ResolveResult, healthResult: AnalysisBundle["health"], licenseResult: AnalysisBundle["licenses"], unusedResult: UnusedResult, config: {
+    includeChangelog?: boolean;
+}): Promise<ReviewItem[]>;

package/dist/core/analysis/review-items.js

@@ -0,0 +1,128 @@
+import { fetchChangelog } from "../../commands/changelog/fetcher.js";
+import { applyRiskAssessments } from "../../risk/index.js";
+import { applyImpactScores } from "../impact.js";
+export async function buildReviewItems(updates, auditResult, resolveResult, healthResult, licenseResult, unusedResult, config) {
+    const advisoryPackages = new Set(auditResult.packages.map((pkg) => pkg.packageName));
+    const impactedUpdates = applyImpactScores(updates, {
+        advisoryPackages,
+        workspaceDependentCount: (name) => updates.filter((item) => item.name === name).length,
+    });
+    const healthByName = new Map(healthResult.metrics.map((metric) => [metric.name, metric]));
+    const advisoriesByName = new Map();
+    const conflictsByName = new Map();
+    const licenseByName = new Map(licenseResult.packages.map((pkg) => [pkg.name, pkg]));
+    const licenseViolationNames = new Set(licenseResult.violations.map((pkg) => pkg.name));
+    const unusedByName = new Map();
+    for (const advisory of auditResult.advisories) {
+        const list = advisoriesByName.get(advisory.packageName) ?? [];
+        list.push(advisory);
+        advisoriesByName.set(advisory.packageName, list);
+    }
+    for (const conflict of resolveResult.conflicts) {
+        const list = conflictsByName.get(conflict.requester) ?? [];
+        list.push(conflict);
+        conflictsByName.set(conflict.requester, list);
+        const peerList = conflictsByName.get(conflict.peer) ?? [];
+        peerList.push(conflict);
+        conflictsByName.set(conflict.peer, peerList);
+    }
+    for (const issue of [...unusedResult.unused, ...unusedResult.missing]) {
+        const list = unusedByName.get(issue.name) ?? [];
+        list.push(issue);
+        unusedByName.set(issue.name, list);
+    }
+    const enrichedUpdates = await maybeAttachReleaseNotes(impactedUpdates, Boolean(config.includeChangelog));
+    return applyRiskAssessments(enrichedUpdates.map((update) => enrichUpdate(update, advisoriesByName, conflictsByName, healthByName, licenseByName, licenseViolationNames, unusedByName)), {
+        knownPackageNames: new Set(updates.map((item) => item.name)),
+    }).map((item) => ({
+        ...item,
+        update: {
+            ...item.update,
+            policyAction: derivePolicyAction(item),
+            decisionState: deriveDecisionState(item),
+            selectedByDefault: deriveDecisionState(item) !== "blocked",
+            blockedReason: deriveDecisionState(item) === "blocked"
+                ? item.update.recommendedAction
+                : undefined,
+            monitorReason: item.update.healthStatus === "stale" ? "Package health should be monitored." : undefined,
+        },
+    }));
+}
+function enrichUpdate(update, advisoriesByName, conflictsByName, healthByName, licenseByName, licenseViolationNames, unusedByName) {
+    const advisories = advisoriesByName.get(update.name) ?? [];
+    const peerConflicts = conflictsByName.get(update.name) ?? [];
+    const health = healthByName.get(update.name);
+    const license = licenseByName.get(update.name);
+    const unusedIssues = unusedByName.get(update.name) ?? [];
+    return {
+        update: {
+            ...update,
+            advisoryCount: advisories.length,
+            peerConflictSeverity: peerConflicts.some((item) => item.severity === "error")
+                ? "error"
+                : peerConflicts.length > 0
+                    ? "warning"
+                    : "none",
+            licenseStatus: licenseViolationNames.has(update.name)
+                ? "denied"
+                : license
+                    ? "allowed"
+                    : "review",
+            healthStatus: health?.flags[0] ?? "healthy",
+        },
+        advisories,
+        health,
+        peerConflicts,
+        license,
+        unusedIssues,
+        selected: true,
+    };
+}
+function derivePolicyAction(item) {
+    if (item.update.peerConflictSeverity === "error" || item.update.licenseStatus === "denied") {
+        return "block";
+    }
+    if ((item.update.advisoryCount ?? 0) > 0 || item.update.riskLevel === "critical") {
+        return "review";
+    }
+    if (item.update.healthStatus === "stale" || item.update.healthStatus === "archived") {
+        return "monitor";
+    }
+    return "allow";
+}
+function deriveDecisionState(item) {
+    if (item.update.peerConflictSeverity === "error" || item.update.licenseStatus === "denied") {
+        return "blocked";
+    }
+    if ((item.update.advisoryCount ?? 0) > 0 || item.update.riskLevel === "critical") {
+        return "actionable";
+    }
+    if (item.update.riskLevel === "high" || item.update.diffType === "major") {
+        return "review";
+    }
+    return "safe";
+}
+async function maybeAttachReleaseNotes(updates, includeChangelog) {
+    if (!includeChangelog || updates.length === 0) {
+        return updates;
+    }
+    return Promise.all(updates.map(async (update) => ({
+        ...update,
+        releaseNotesSummary: summarizeChangelog(await fetchChangelog(update.name, update.repository)),
+    })));
+}
+function summarizeChangelog(content) {
+    if (!content)
+        return undefined;
+    const lines = content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+    const title = lines.find((line) => line.startsWith("#"))?.replace(/^#+\s*/, "") ?? "Release notes";
+    const excerpt = lines.find((line) => !line.startsWith("#")) ?? "No summary available.";
+    return {
+        source: content.includes("# Release") ? "github-release" : "changelog-file",
+        title,
+        excerpt: excerpt.slice(0, 240),
+    };
+}

package/dist/core/analysis/run-silenced.d.ts

@@ -0,0 +1 @@
+export declare function runSilenced<T>(fn: () => Promise<T>): Promise<T>;