@rainy-updates/cli 0.5.1 → 0.5.2-rc.2

package/dist/commands/resolve/parser.js

@@ -0,0 +1,89 @@
+export function parseResolveArgs(args) {
+    const options = {
+        cwd: process.cwd(),
+        workspace: false,
+        afterUpdate: false,
+        safe: false,
+        jsonFile: undefined,
+        concurrency: 12,
+        registryTimeoutMs: 10_000,
+        cacheTtlSeconds: 3600,
+    };
+    for (let i = 0; i < args.length; i++) {
+        const current = args[i];
+        const next = args[i + 1];
+        if (current === "--cwd" && next) {
+            options.cwd = next;
+            i++;
+            continue;
+        }
+        if (current === "--cwd")
+            throw new Error("Missing value for --cwd");
+        if (current === "--workspace") {
+            options.workspace = true;
+            continue;
+        }
+        if (current === "--after-update") {
+            options.afterUpdate = true;
+            continue;
+        }
+        if (current === "--safe") {
+            options.safe = true;
+            continue;
+        }
+        if (current === "--json-file" && next) {
+            options.jsonFile = next;
+            i++;
+            continue;
+        }
+        if (current === "--json-file")
+            throw new Error("Missing value for --json-file");
+        if (current === "--concurrency" && next) {
+            const n = Number(next);
+            if (!Number.isInteger(n) || n <= 0)
+                throw new Error("--concurrency must be a positive integer");
+            options.concurrency = n;
+            i++;
+            continue;
+        }
+        if (current === "--concurrency")
+            throw new Error("Missing value for --concurrency");
+        if (current === "--timeout" && next) {
+            const ms = Number(next);
+            if (!Number.isFinite(ms) || ms <= 0)
+                throw new Error("--timeout must be a positive number");
+            options.registryTimeoutMs = ms;
+            i++;
+            continue;
+        }
+        if (current === "--timeout")
+            throw new Error("Missing value for --timeout");
+        if (current === "--help" || current === "-h") {
+            process.stdout.write(RESOLVE_HELP);
+            process.exit(0);
+        }
+        if (current.startsWith("-"))
+            throw new Error(`Unknown option: ${current}`);
+    }
+    return options;
+}
+const RESOLVE_HELP = `
+rup resolve — Detect peer dependency conflicts (pure-TS, no subprocess spawn)
+
+Usage:
+  rup resolve [options]
+
+Options:
+  --after-update        Simulate conflicts after applying pending \`rup check\` updates
+  --safe                Exit non-zero if any error-level conflicts exist
+  --workspace           Scan all workspace packages
+  --json-file <path>    Write JSON conflict report to file
+  --timeout <ms>        Registry request timeout in ms (default: 10000)
+  --concurrency <n>     Parallel registry requests (default: 12)
+  --cwd <path>          Working directory (default: cwd)
+  --help                Show this help
+
+Exit codes:
+  0  No conflicts
+  1  One or more peer conflicts detected
+`.trimStart();

package/dist/commands/resolve/runner.d.ts

@@ -0,0 +1,13 @@
+import type { ResolveOptions, ResolveResult } from "../../types/index.js";
+/**
+ * Entry point for `rup resolve`. Lazy-loaded by cli.ts.
+ *
+ * Modes:
+ *   default          — check current peer-dep state for conflicts
+ *   --after-update   — re-check after applying pending `rup check` updates
+ *                      in-memory (reads proposed versions from check runner)
+ *
+ * The pure-TS peer graph is assembled entirely from registry data; no subprocess
+ * is spawned. When the cache is warm this completes in < 1 s for typical projects.
+ */
+export declare function runResolve(options: ResolveOptions): Promise<ResolveResult>;

package/dist/commands/resolve/runner.js

@@ -0,0 +1,136 @@
+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";
+/**
+ * Entry point for `rup resolve`. Lazy-loaded by cli.ts.
+ *
+ * Modes:
+ *   default          — check current peer-dep state for conflicts
+ *   --after-update   — re-check after applying pending `rup check` updates
+ *                      in-memory (reads proposed versions from check runner)
+ *
+ * The pure-TS peer graph is assembled entirely from registry data; no subprocess
+ * is spawned. When the cache is warm this completes in < 1 s for typical projects.
+ */
+export async function runResolve(options) {
+    const result = {
+        conflicts: [],
+        errorConflicts: 0,
+        warningConflicts: 0,
+        errors: [],
+        warnings: [],
+    };
+    let versionOverrides;
+    if (options.afterUpdate) {
+        versionOverrides = await fetchProposedVersions(options);
+        if (versionOverrides.size === 0) {
+            process.stderr.write("[resolve] No pending updates found — checking current state.\n");
+        }
+    }
+    let graph;
+    try {
+        graph = await buildPeerGraph(options, versionOverrides);
+    }
+    catch (err) {
+        result.errors.push(`Failed to build peer graph: ${String(err)}`);
+        return result;
+    }
+    const conflicts = resolvePeerConflicts(graph);
+    result.conflicts = conflicts;
+    result.errorConflicts = conflicts.filter((c) => c.severity === "error").length;
+    result.warningConflicts = conflicts.filter((c) => c.severity === "warning").length;
+    process.stdout.write(renderConflictsTable(result, options) + "\n");
+    if (options.jsonFile) {
+        await writeFileAtomic(options.jsonFile, stableStringify(result, 2) + "\n");
+        process.stderr.write(`[resolve] JSON report written to ${options.jsonFile}\n`);
+    }
+    return result;
+}
+/**
+ * In --after-update mode, runs `rup check` logic in read-only mode to get
+ * the proposed new versions, returning them as a version override map.
+ */
+async function fetchProposedVersions(options) {
+    const overrides = new Map();
+    try {
+        const { check } = await import("../../core/check.js");
+        const checkResult = await check({
+            cwd: options.cwd,
+            workspace: options.workspace,
+            concurrency: options.concurrency,
+            target: "latest",
+            filter: undefined,
+            reject: undefined,
+            includeKinds: ["dependencies", "devDependencies", "optionalDependencies"],
+            ci: false,
+            format: "table",
+            jsonFile: undefined,
+            githubOutputFile: undefined,
+            sarifFile: undefined,
+            cacheTtlSeconds: options.cacheTtlSeconds,
+            registryTimeoutMs: options.registryTimeoutMs,
+            registryRetries: 2,
+            offline: false,
+            stream: false,
+            policyFile: undefined,
+            prReportFile: undefined,
+            failOn: "none",
+            maxUpdates: undefined,
+            fixPr: false,
+            fixBranch: "chore/rainy-updates",
+            fixCommitMessage: undefined,
+            fixDryRun: false,
+            fixPrNoCheckout: false,
+            fixPrBatchSize: undefined,
+            noPrReport: false,
+            logLevel: "info",
+            groupBy: "none",
+            groupMax: undefined,
+            cooldownDays: undefined,
+            prLimit: undefined,
+            onlyChanged: false,
+            ciProfile: "minimal",
+            lockfileMode: "preserve",
+        });
+        for (const update of checkResult.updates ?? []) {
+            overrides.set(update.name, update.toVersionResolved);
+        }
+    }
+    catch {
+        // If check fails, fall back to current state (no overrides)
+    }
+    return overrides;
+}
+function renderConflictsTable(result, options) {
+    const { conflicts } = result;
+    if (conflicts.length === 0) {
+        return options.afterUpdate
+            ? "✔ No peer conflicts detected after proposed updates are applied."
+            : "✔ No peer conflicts detected in current dependency tree.";
+    }
+    const lines = [];
+    const header = options.afterUpdate
+        ? `\nPeer conflicts after proposed updates (${conflicts.length} found):\n`
+        : `\nPeer conflicts in current dependency tree (${conflicts.length} found):\n`;
+    lines.push(header);
+    const errors = conflicts.filter((c) => c.severity === "error");
+    const warnings = conflicts.filter((c) => c.severity === "warning");
+    if (errors.length > 0) {
+        lines.push(`  ✖ Errors (${errors.length}) — would cause ERESOLVE on install:\n`);
+        for (const c of errors) {
+            lines.push(`    \x1b[31m✖\x1b[0m ${c.requester}  requires  ${c.peer}@${c.requiredRange}  got  ${c.resolvedVersion}`);
+            lines.push(`      → ${c.suggestion}`);
+        }
+        lines.push("");
+    }
+    if (warnings.length > 0) {
+        lines.push(`  ⚠ Warnings (${warnings.length}) — soft peer incompatibilities:\n`);
+        for (const c of warnings) {
+            lines.push(`    \x1b[33m⚠\x1b[0m ${c.requester}  requires  ${c.peer}@${c.requiredRange}  got  ${c.resolvedVersion}`);
+            lines.push(`      → ${c.suggestion}`);
+        }
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,2 @@
+import type { SnapshotOptions } from "../../types/index.js";
+export declare function parseSnapshotArgs(args: string[]): SnapshotOptions;

package/dist/commands/snapshot/parser.js

@@ -0,0 +1,80 @@
+const VALID_ACTIONS = ["save", "list", "restore", "diff"];
+export function parseSnapshotArgs(args) {
+    const options = {
+        cwd: process.cwd(),
+        workspace: false,
+        action: "list",
+        label: undefined,
+        snapshotId: undefined,
+        storeFile: undefined,
+    };
+    // First positional arg is the action
+    let positionalIndex = 0;
+    const positionals = [];
+    for (let i = 0; i < args.length; i++) {
+        const current = args[i];
+        const next = args[i + 1];
+        if (current === "--cwd" && next) {
+            options.cwd = next;
+            i++;
+            continue;
+        }
+        if (current === "--cwd")
+            throw new Error("Missing value for --cwd");
+        if (current === "--workspace") {
+            options.workspace = true;
+            continue;
+        }
+        if (current === "--label" && next) {
+            options.label = next;
+            i++;
+            continue;
+        }
+        if (current === "--label")
+            throw new Error("Missing value for --label");
+        if (current === "--store" && next) {
+            options.storeFile = next;
+            i++;
+            continue;
+        }
+        if (current === "--store")
+            throw new Error("Missing value for --store");
+        if (current === "--help" || current === "-h") {
+            process.stdout.write(SNAPSHOT_HELP);
+            process.exit(0);
+        }
+        if (current.startsWith("-"))
+            throw new Error(`Unknown option: ${current}`);
+        // Positional arguments
+        positionals.push(current);
+    }
+    // positionals[0] = action, positionals[1] = id/label for restore/diff
+    if (positionals.length >= 1) {
+        const action = positionals[0];
+        if (!VALID_ACTIONS.includes(action)) {
+            throw new Error(`Unknown snapshot action: "${positionals[0]}". Valid: ${VALID_ACTIONS.join(", ")}`);
+        }
+        options.action = action;
+    }
+    if (positionals.length >= 2) {
+        // For restore/diff the second positional is the id/label
+        options.snapshotId = positionals[1];
+    }
+    return options;
+}
+const SNAPSHOT_HELP = `
+rup snapshot — Save, list, restore, and diff dependency state snapshots
+
+Usage:
+  rup snapshot save [--label <name>]    Save current dependency state
+  rup snapshot list                     List all saved snapshots
+  rup snapshot restore <id|label>       Restore package.json files from a snapshot
+  rup snapshot diff <id|label>          Show changes since a snapshot
+
+Options:
+  --label <name>        Human-readable label for the snapshot
+  --store <path>        Custom snapshot store file (default: .rup-snapshots.json)
+  --workspace           Include all workspace packages
+  --cwd <path>          Working directory (default: cwd)
+  --help                Show this help
+`.trimStart();

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

@@ -0,0 +1,11 @@
+import type { SnapshotOptions, SnapshotResult } from "../../types/index.js";
+/**
+ * Entry point for `rup snapshot`. Lazy-loaded by cli.ts.
+ *
+ * Actions:
+ *   save     — Capture package.json + lockfile state → store
+ *   list     — Print all saved snapshots
+ *   restore  — Restore a snapshot by id or label
+ *   diff     — Show dependency changes since a snapshot
+ */
+export declare function runSnapshot(options: SnapshotOptions): Promise<SnapshotResult>;

package/dist/commands/snapshot/runner.js

@@ -0,0 +1,115 @@
+import process from "node:process";
+import { discoverPackageDirs } from "../../workspace/discover.js";
+import { SnapshotStore, captureState, restoreState, diffManifests, } from "./store.js";
+/**
+ * Entry point for `rup snapshot`. Lazy-loaded by cli.ts.
+ *
+ * Actions:
+ *   save     — Capture package.json + lockfile state → store
+ *   list     — Print all saved snapshots
+ *   restore  — Restore a snapshot by id or label
+ *   diff     — Show dependency changes since a snapshot
+ */
+export async function runSnapshot(options) {
+    const result = {
+        action: options.action,
+        errors: [],
+        warnings: [],
+    };
+    const packageDirs = await discoverPackageDirs(options.cwd, options.workspace);
+    const store = new SnapshotStore(options.cwd, options.storeFile);
+    switch (options.action) {
+        // ─ save ──────────────────────────────────────────────────────────────────
+        case "save": {
+            const label = options.label ??
+                `snap-${new Date().toISOString().replace(/[:T]/g, "-").slice(0, 19)}`;
+            const { manifests, lockfileHashes } = await captureState(packageDirs);
+            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`);
+            break;
+        }
+        // ─ list ──────────────────────────────────────────────────────────────────
+        case "list": {
+            const entries = await store.listSnapshots();
+            result.entries = entries.map((e) => ({
+                id: e.id,
+                label: e.label,
+                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");
+            }
+            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");
+                for (const e of entries) {
+                    process.stdout.write("  " +
+                        e.id.padEnd(30) +
+                        e.label.padEnd(30) +
+                        new Date(e.createdAt).toLocaleString() +
+                        "\n");
+                }
+                process.stdout.write("\n");
+            }
+            break;
+        }
+        // ─ restore ───────────────────────────────────────────────────────────────
+        case "restore": {
+            const idOrLabel = options.snapshotId ?? options.label;
+            if (!idOrLabel) {
+                result.errors.push("Restore requires a snapshot ID or label. Usage: rup snapshot restore <id|label>");
+                break;
+            }
+            const entry = await store.findSnapshot(idOrLabel);
+            if (!entry) {
+                result.errors.push(`Snapshot not found: ${idOrLabel}. Use \`rup snapshot list\` to view saved snapshots.`);
+                break;
+            }
+            await restoreState(entry);
+            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");
+            break;
+        }
+        // ─ diff ──────────────────────────────────────────────────────────────────
+        case "diff": {
+            const idOrLabel = options.snapshotId ?? options.label;
+            if (!idOrLabel) {
+                result.errors.push("Diff requires a snapshot ID or label. Usage: rup snapshot diff <id|label>");
+                break;
+            }
+            const entry = await store.findSnapshot(idOrLabel);
+            if (!entry) {
+                result.errors.push(`Snapshot not found: ${idOrLabel}`);
+                break;
+            }
+            const { manifests: currentManifests } = await captureState(packageDirs);
+            const changes = diffManifests(entry.manifests, currentManifests);
+            result.diff = changes;
+            if (changes.length === 0) {
+                process.stdout.write(`✔ 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");
+                for (const c of changes) {
+                    process.stdout.write("  " + c.name.padEnd(35) + c.from.padEnd(20) + c.to + "\n");
+                }
+                process.stdout.write("\n");
+            }
+            break;
+        }
+    }
+    if (result.errors.length > 0) {
+        for (const err of result.errors) {
+            process.stderr.write(`[snapshot] ✖ ${err}\n`);
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,35 @@
+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;
+    private loaded;
+    constructor(cwd: string, storeFile?: string);
+    load(): Promise<void>;
+    save(): Promise<void>;
+    saveSnapshot(manifests: Record<string, string>, lockfileHashes: Record<string, string>, label: string): Promise<SnapshotEntry>;
+    listSnapshots(): Promise<SnapshotEntry[]>;
+    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;
+    to: string;
+}>;

package/dist/commands/snapshot/store.js

@@ -0,0 +1,158 @@
+import { createHash } from "node:crypto";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+const DEFAULT_STORE_NAME = ".rup-snapshots.json";
+/**
+ * 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 class SnapshotStore {
+    storePath;
+    entries = [];
+    loaded = false;
+    constructor(cwd, storeFile) {
+        this.storePath = storeFile
+            ? path.isAbsolute(storeFile)
+                ? storeFile
+                : path.join(cwd, storeFile)
+            : path.join(cwd, DEFAULT_STORE_NAME);
+    }
+    async load() {
+        if (this.loaded)
+            return;
+        try {
+            const raw = await fs.readFile(this.storePath, "utf8");
+            const parsed = JSON.parse(raw);
+            if (Array.isArray(parsed)) {
+                this.entries = parsed;
+            }
+        }
+        catch {
+            this.entries = [];
+        }
+        this.loaded = true;
+    }
+    async save() {
+        const tmp = this.storePath + ".tmp";
+        await fs.writeFile(tmp, JSON.stringify(this.entries, null, 2) + "\n", "utf8");
+        await fs.rename(tmp, this.storePath);
+    }
+    async saveSnapshot(manifests, lockfileHashes, label) {
+        await this.load();
+        const id = `snap-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
+        const entry = {
+            id,
+            label,
+            createdAt: Date.now(),
+            manifests,
+            lockfileHashes,
+        };
+        this.entries.push(entry);
+        await this.save();
+        return entry;
+    }
+    async listSnapshots() {
+        await this.load();
+        return [...this.entries].sort((a, b) => b.createdAt - a.createdAt);
+    }
+    async findSnapshot(idOrLabel) {
+        await this.load();
+        return (this.entries.find((e) => e.id === idOrLabel || e.label === idOrLabel) ??
+            null);
+    }
+    async deleteSnapshot(idOrLabel) {
+        await this.load();
+        const before = this.entries.length;
+        this.entries = this.entries.filter((e) => e.id !== idOrLabel && e.label !== idOrLabel);
+        if (this.entries.length < before) {
+            await this.save();
+            return true;
+        }
+        return false;
+    }
+}
+/** Captures current package.json and lockfile state for a set of directories. */
+export async function captureState(packageDirs) {
+    const manifests = {};
+    const lockfileHashes = {};
+    const LOCKFILES = [
+        "package-lock.json",
+        "pnpm-lock.yaml",
+        "yarn.lock",
+        "bun.lockb",
+    ];
+    await Promise.all(packageDirs.map(async (dir) => {
+        // Read package.json
+        try {
+            const content = await fs.readFile(path.join(dir, "package.json"), "utf8");
+            manifests[dir] = content;
+        }
+        catch {
+            // No package.json — skip
+        }
+        // Hash the first lockfile found
+        for (const lf of LOCKFILES) {
+            try {
+                const content = await fs.readFile(path.join(dir, lf));
+                lockfileHashes[dir] = createHash("sha256")
+                    .update(content)
+                    .digest("hex");
+                break;
+            }
+            catch {
+                // Try next
+            }
+        }
+    }));
+    return { manifests, lockfileHashes };
+}
+/** Restores package.json files from a snapshot's manifest map. */
+export async function restoreState(entry) {
+    await Promise.all(Object.entries(entry.manifests).map(async ([dir, content]) => {
+        const manifestPath = path.join(dir, "package.json");
+        const tmp = manifestPath + ".tmp";
+        await fs.writeFile(tmp, content, "utf8");
+        await fs.rename(tmp, manifestPath);
+    }));
+}
+/** Computes a diff of dependency versions between two manifest snapshots. */
+export function diffManifests(before, after) {
+    const changes = [];
+    for (const [dir, afterJson] of Object.entries(after)) {
+        const beforeJson = before[dir];
+        if (!beforeJson)
+            continue;
+        let beforeManifest;
+        let afterManifest;
+        try {
+            beforeManifest = JSON.parse(beforeJson);
+            afterManifest = JSON.parse(afterJson);
+        }
+        catch {
+            continue;
+        }
+        const fields = [
+            "dependencies",
+            "devDependencies",
+            "optionalDependencies",
+        ];
+        for (const field of fields) {
+            const before = beforeManifest[field] ?? {};
+            const after = afterManifest[field] ?? {};
+            const allNames = new Set([...Object.keys(before), ...Object.keys(after)]);
+            for (const name of allNames) {
+                const fromVer = before[name] ?? "(removed)";
+                const toVer = after[name] ?? "(removed)";
+                if (fromVer !== toVer) {
+                    changes.push({ name, from: fromVer, to: toVer });
+                }
+            }
+        }
+    }
+    return changes;
+}

package/dist/commands/unused/matcher.d.ts

@@ -0,0 +1,22 @@
+import type { PackageManifest } from "../../types/index.js";
+import type { UnusedDependency } from "../../types/index.js";
+/**
+ * Cross-references declared package.json dependencies against imported package names
+ * to surface two classes of problems:
+ *
+ *   - "declared-not-imported": in package.json but never imported in source
+ *   - "imported-not-declared": imported in source but absent from package.json
+ */
+export interface MatchOptions {
+    includeDevDependencies: boolean;
+}
+export declare function matchDependencies(manifest: PackageManifest, importedPackages: Set<string>, packageDir: string, options: MatchOptions): {
+    unused: UnusedDependency[];
+    missing: UnusedDependency[];
+};
+/**
+ * Applies the unused/missing result of `matchDependencies` to a package.json
+ * manifest in-memory, removing `unused` entries. Returns the modified manifest
+ * as a formatted JSON string ready to write back to disk.
+ */
+export declare function removeUnusedFromManifest(manifestJson: string, unused: UnusedDependency[]): string;