canary-test-cli 6.8.0 → 7.0.0

package/dist/overlay-commands.js

@@ -446,7 +446,10 @@ function updateOne(o, git, out, err) {
     }
     if (clean === 'dirty') {
         err.write(`overlay "${o.name}": local modifications in ${o.path} — refusing to update. ` +
-            `Commit/stash them, or 'canary overlay remove ${o.name}' and re-add.\n`);
+            `Commit/stash them, or discard them with ` +
+            `'canary overlay remove ${o.name} --force' and re-add. ` +
+            `(Plain 'overlay remove' refuses on a dirty clone too, so it will not ` +
+            `throw the edits away by accident.)\n`);
         return 1;
     }
     if (o.ref) {
@@ -520,8 +523,15 @@ function update(name, deps = {}) {
 /**
  * `canary overlay remove <name>` — deregister an overlay and delete its clone.
  * Unknown name is an error; the registry is left unchanged in that case.
+ *
+ * Removal is destructive and irreversible, so it takes the same posture as
+ * `overlay update` (#675): a clone with local modifications — or one whose git
+ * status cannot be read, which is no safer to delete blind — is refused, and
+ * `--force` is the explicit opt-in. A clone that is already gone is not a
+ * refusal: there is nothing left to lose, so the stale registry row is dropped.
  */
-function remove(name, deps = {}) {
+function remove(name, deps = {}, opts = {}) {
+    const git = deps.git ?? defaultGit;
     const homeDir = deps.homeDir ?? os.homedir();
     const out = deps.out ?? process.stdout;
     const err = deps.err ?? process.stderr;
@@ -538,6 +548,22 @@ function remove(name, deps = {}) {
         err.write(`canary overlay remove: no overlay named "${name}".\n`);
         return 1;
     }
+    if (!opts.force && fs.existsSync(entry.path)) {
+        const clean = workingTreeStatus(entry.path, git);
+        if (clean === 'unreadable') {
+            err.write(`canary overlay remove: cannot read git status at ${entry.path} — ` +
+                `refusing to delete it. Inspect the directory, then re-run with ` +
+                `--force to remove it anyway.\n`);
+            return 1;
+        }
+        if (clean === 'dirty') {
+            err.write(`canary overlay remove: local modifications in ${entry.path} — ` +
+                `refusing to delete them. Commit or discard the changes ` +
+                `(git -C ${entry.path} status), then re-run; or re-run with ` +
+                `--force to delete the clone and the changes.\n`);
+            return 1;
+        }
+    }
     fs.rmSync(entry.path, { recursive: true, force: true });
     const { registry: next } = registry.remove(reg, name);
     registry.write(next, homeDir);

package/dist/router.js

@@ -48,8 +48,13 @@ exports.route = route;
  */
 const overlay = __importStar(require("./overlay-commands.js"));
 const doctor_js_1 = require("./doctor.js");
+const uninstall_js_1 = require("./uninstall.js");
 /** Subcommands handled in TypeScript rather than forwarded to the binary. */
-exports.TS_COMMANDS = ['overlay', 'doctor'];
+exports.TS_COMMANDS = [
+    'overlay',
+    'doctor',
+    'uninstall',
+];
 /** True when `argv` (process.argv.slice(2)) targets a TS-handled command. */
 function isTsCommand(argv) {
     return argv.length > 0 && exports.TS_COMMANDS.includes(argv[0]);
@@ -88,7 +93,7 @@ function refFrom(flags) {
     return typeof ref === 'string' ? ref : null;
 }
 const OVERLAY_USAGE = 'usage: canary overlay <add|list|lint|update|remove> [args]\n' +
-    '  add <source> [--ref <tag>]   list [--conflicts]   lint <name|path> [--json]   update [name]   remove <name>\n';
+    '  add <source> [--ref <tag>]   list [--conflicts]   lint <name|path> [--json]   update [name]   remove <name> [--force]\n';
 /** Overlay subcommand handlers, keyed by name. Each returns a process exit code. */
 const OVERLAY_SUBCOMMANDS = {
     add: ({ positionals, flags, deps, err }) => {
@@ -103,12 +108,16 @@ const OVERLAY_SUBCOMMANDS = {
     list: ({ flags, deps }) => overlay.list(deps, { conflicts: flags.conflicts === true }),
     lint: ({ positionals, flags, deps }) => overlay.lint(positionals[0], deps, { json: flags.json === true }),
     update: ({ positionals, deps }) => overlay.update(positionals[0] ?? null, deps),
-    remove: ({ positionals, deps, err }) => {
+    remove: ({ positionals, flags, deps, err }) => {
         if (positionals.length < 1) {
-            err.write('usage: canary overlay remove <name>\n');
+            err.write('usage: canary overlay remove <name> [--force]\n');
             return 1;
         }
-        return overlay.remove(positionals[0], deps);
+        // `--force` deletes a clone with local modifications (#675); without it,
+        // removal refuses rather than destroying uncommitted work.
+        return overlay.remove(positionals[0], deps, {
+            force: flags.force === true,
+        });
     },
 };
 function runOverlay(args, deps) {
@@ -137,5 +146,8 @@ function route(argv, deps = {}) {
     if (argv[0] === 'doctor') {
         return (0, doctor_js_1.runDoctor)(argv.slice(1), deps);
     }
+    if (argv[0] === 'uninstall') {
+        return (0, uninstall_js_1.run)(argv.slice(1), deps);
+    }
     return null;
 }

package/dist/uninstall-render.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Rendering half of `canary uninstall`. Groups artifacts by disposition and
+ * always states the denominator: a scope with nothing in it says so rather
+ * than printing an empty list that reads as "all clean".
+ */
+import type { Artifact, Scope } from './uninstall-types.js';
+export declare function render(artifacts: Artifact[], opts: {
+    scope: Scope;
+    apply: boolean;
+    failed?: Artifact[];
+}): string;

package/dist/uninstall-render.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = render;
+function human(bytes) {
+    if (bytes === undefined || bytes === 0)
+        return '';
+    const units = ['B', 'K', 'M', 'G'];
+    let n = bytes;
+    let i = 0;
+    while (n >= 1024 && i < units.length - 1) {
+        n /= 1024;
+        i += 1;
+    }
+    return `${n.toFixed(n < 10 && i > 0 ? 1 : 0)}${units[i]}`;
+}
+function render(artifacts, opts) {
+    const lines = [];
+    const mode = opts.apply ? '(apply)' : '(dry run)';
+    lines.push(`canary uninstall --${opts.scope} ${mode}`, '');
+    // `disposition` records what the scan decided, not what the removal achieved.
+    // A failed rmSync leaves the artifact `removable`, so rendering straight from
+    // the disposition would report it as removed — a clean-looking summary over
+    // work that did not happen.
+    const failedSet = new Set(opts.failed ?? []);
+    const removable = artifacts.filter((a) => a.disposition === 'removable' && !failedSet.has(a));
+    const failed = artifacts.filter((a) => failedSet.has(a));
+    const blocked = artifacts.filter((a) => a.disposition === 'blocked');
+    const manual = artifacts.filter((a) => a.disposition === 'manual');
+    const section = (title, rows) => {
+        if (rows.length === 0)
+            return;
+        lines.push(`  ${title} (${rows.length})`);
+        for (const a of rows) {
+            const size = human(a.sizeBytes);
+            const tail = a.reason ? `  — ${a.reason}` : '';
+            lines.push(`    ${a.label}${size ? `  ${size}` : ''}${a.path ? `\n      ${a.path}` : ''}${tail}`);
+        }
+        lines.push('');
+    };
+    section(opts.apply ? 'Removed' : 'Removable', removable);
+    section('FAILED to remove', failed);
+    section('Skipped', blocked);
+    section('You must do these yourself', manual);
+    // A zero denominator is an abstention, not a pass: say so explicitly rather
+    // than printing an empty list that reads as "all clean".
+    if (artifacts.length === 0) {
+        lines.push('  Nothing found for this scope — nothing to remove.', '');
+        return lines.join('\n');
+    }
+    if (removable.length === 0) {
+        lines.push('  Nothing removable for this scope.');
+    }
+    const summary = `  ${removable.length} ${opts.apply ? 'removed' : 'removable'}, ` +
+        (failed.length > 0 ? `${failed.length} FAILED, ` : '') +
+        `${blocked.length} skipped, ${manual.length} manual.`;
+    lines.push(opts.apply
+        ? summary
+        : `${summary} Nothing was removed — re-run with --apply.`);
+    return lines.join('\n');
+}

package/dist/uninstall-scan.d.ts

@@ -0,0 +1,14 @@
+import { type Artifact, type EnumerateOptions, type UninstallDeps } from './uninstall-types.js';
+export declare function enumerate(opts: EnumerateOptions, deps?: UninstallDeps): Artifact[];
+export interface RemovalOutcome {
+    removed: Artifact[];
+    failed: Array<{
+        artifact: Artifact;
+        error: string;
+    }>;
+}
+/**
+ * Remove `.canary/` while preserving the quarantine ledger when it was not
+ * opted into. Deleting the directory wholesale would take the ledger with it,
+ * silently undoing the protection the `blocked` disposition just promised.
+ */

package/dist/uninstall-scan.js

@@ -0,0 +1,273 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumerate = enumerate;
+/**
+ * Enumeration half of `canary uninstall` — walks the install footprint and
+ * classifies every artifact it finds. Pure discovery: nothing here writes or
+ * deletes, so the dry-run and `--apply` paths read from one source of truth.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const registry = __importStar(require("./overlays-registry.js"));
+const overlay_commands_js_1 = require("./overlay-commands.js");
+const uninstall_types_js_1 = require("./uninstall-types.js");
+/**
+ * Every install path Claude Code currently considers live.
+ *
+ * Read from `installPath`, NEVER inferred by sorting version numbers: a real
+ * machine had 4.0.0, 6.3.0, 6.4.0, 6.5.0, 6.6.0 and 6.7.1 cached with **6.4.0**
+ * registered, so a highest-version heuristic would delete the live install and
+ * leave five orphans. Every entry counts (a plugin may be registered at more
+ * than one scope), so all of them are protected.
+ */
+function registeredInstallPaths(pluginsDir) {
+    const manifest = (0, uninstall_types_js_1.readJson)(path.join(pluginsDir, 'installed_plugins.json'));
+    const entries = manifest?.plugins?.[uninstall_types_js_1.PLUGIN_KEY];
+    const out = new Set();
+    if (!Array.isArray(entries))
+        return out;
+    for (const e of entries) {
+        const p = e?.installPath;
+        if (typeof p === 'string' && p.length > 0)
+            out.add(path.resolve(p));
+    }
+    return out;
+}
+function enumerateGlobal(opts, deps) {
+    const home = deps.homeDir ?? os.homedir();
+    const git = deps.git ?? uninstall_types_js_1.defaultGit;
+    const found = [];
+    const pluginsDir = path.join(home, '.claude', 'plugins');
+    const cacheRoot = path.join(pluginsDir, 'cache', uninstall_types_js_1.MARKETPLACE, 'canary');
+    const registered = registeredInstallPaths(pluginsDir);
+    let versions = [];
+    try {
+        versions = fs
+            .readdirSync(cacheRoot, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        versions = [];
+    }
+    for (const v of versions.sort()) {
+        const dir = path.join(cacheRoot, v);
+        const isLive = registered.has(path.resolve(dir));
+        found.push({
+            scope: 'global',
+            kind: 'plugin-cache',
+            label: `plugin cache ${v}`,
+            path: dir,
+            disposition: isLive ? 'blocked' : 'removable',
+            reason: isLive
+                ? 'currently registered — run `/plugin uninstall` first, then re-run'
+                : undefined,
+            sizeBytes: (0, uninstall_types_js_1.dirSize)(dir),
+        });
+    }
+    if (registered.size > 0) {
+        found.push({
+            scope: 'global',
+            kind: 'plugin-registration',
+            label: 'Claude Code plugin registration',
+            path: path.join(pluginsDir, 'installed_plugins.json'),
+            disposition: 'manual',
+            reason: `/plugin uninstall ${uninstall_types_js_1.PLUGIN_KEY}`,
+        });
+    }
+    const marketplace = path.join(pluginsDir, 'marketplaces', uninstall_types_js_1.MARKETPLACE);
+    if (fs.existsSync(marketplace)) {
+        found.push({
+            scope: 'global',
+            kind: 'marketplace',
+            label: 'marketplace clone',
+            path: marketplace,
+            disposition: 'manual',
+            reason: `/plugin marketplace remove ${uninstall_types_js_1.MARKETPLACE}`,
+            sizeBytes: (0, uninstall_types_js_1.dirSize)(marketplace),
+        });
+    }
+    // Overlays: skip dirty, remove clean — via the same `workingTreeStatus` the
+    // `overlay update`, `overlay remove` (#675), and doctor paths consult, so the
+    // removal paths cannot drift apart about whether local edits are safe.
+    // A git runner that could not report (`status: null`) maps to a non-zero
+    // status, i.e. `unreadable`, which is treated as dirty: a clone whose state
+    // cannot be read is not one to sweep away.
+    const overlayGit = (args, opts) => {
+        const r = git(args, opts);
+        return { status: r.status ?? 1, stdout: r.stdout, stderr: r.stderr };
+    };
+    let overlays = [];
+    try {
+        overlays = registry.list(registry.read(home));
+    }
+    catch {
+        overlays = [];
+    }
+    for (const entry of overlays) {
+        const exists = fs.existsSync(entry.path);
+        const dirty = exists
+            ? (0, overlay_commands_js_1.workingTreeStatus)(entry.path, overlayGit) !== 'clean'
+            : false;
+        found.push({
+            scope: 'global',
+            kind: 'overlay',
+            label: `overlay ${entry.name}`,
+            path: entry.path,
+            disposition: dirty ? 'blocked' : 'removable',
+            reason: dirty
+                ? 'has local edits — commit or discard them first'
+                : undefined,
+            sizeBytes: exists ? (0, uninstall_types_js_1.dirSize)(entry.path) : 0,
+        });
+    }
+    found.push({
+        scope: 'global',
+        kind: 'cli-binary',
+        label: 'CLI binary',
+        path: deps.cliPath ?? process.argv[1] ?? null,
+        disposition: 'manual',
+        reason: cliRemovalHint(deps.cliPath ?? process.argv[1] ?? ''),
+    });
+    return found;
+}
+/**
+ * The removal command for however the CLI was installed. Detection is a hint,
+ * not a claim — an unrecognised root falls back to naming all of them rather
+ * than guessing one.
+ */
+function cliRemovalHint(cliPath) {
+    const p = cliPath.toLowerCase();
+    if (p.includes('volta'))
+        return 'volta uninstall canary-test-cli';
+    if (p.includes('mise') || p.includes('.asdf'))
+        return 'mise unuse -g npm:canary-test-cli';
+    if (p.includes('node_modules'))
+        return 'npm uninstall -g canary-test-cli';
+    return 'npm uninstall -g canary-test-cli   (or volta/mise equivalent)';
+}
+function enumerateProject(opts, deps) {
+    const cwd = deps.cwd ?? process.cwd();
+    const found = [];
+    const includeGenerated = opts.includeGenerated === true;
+    const canaryDir = path.join(cwd, '.canary');
+    const quarantine = path.join(canaryDir, 'quarantine.json');
+    const hasQuarantine = fs.existsSync(quarantine);
+    if (fs.existsSync(canaryDir)) {
+        found.push({
+            scope: 'project',
+            kind: 'project-config',
+            label: '.canary/ project config',
+            path: canaryDir,
+            disposition: 'removable',
+            sizeBytes: (0, uninstall_types_js_1.dirSize)(canaryDir),
+        });
+    }
+    if (hasQuarantine) {
+        found.push({
+            scope: 'project',
+            kind: 'quarantine-ledger',
+            label: '.canary/quarantine.json (deleted-test ledger)',
+            path: quarantine,
+            disposition: includeGenerated ? 'removable' : 'blocked',
+            reason: includeGenerated
+                ? undefined
+                : `records why tests were deleted — pass --include-generated to remove`,
+            sizeBytes: (0, uninstall_types_js_1.dirSize)(quarantine),
+        });
+    }
+    const reports = path.join(cwd, 'test-results', 'reports');
+    if (fs.existsSync(reports)) {
+        found.push({
+            scope: 'project',
+            kind: 'project-reports',
+            label: 'test-results/reports/',
+            path: reports,
+            disposition: 'removable',
+            sizeBytes: (0, uninstall_types_js_1.dirSize)(reports),
+        });
+    }
+    const generated = path.join(cwd, 'tests', 'generated');
+    if (fs.existsSync(generated)) {
+        let count = 0;
+        try {
+            count = fs.readdirSync(generated).length;
+        }
+        catch {
+            count = 0;
+        }
+        found.push({
+            scope: 'project',
+            kind: 'generated-tests',
+            label: `tests/generated/ (${count} file(s))`,
+            path: generated,
+            disposition: includeGenerated ? 'removable' : 'blocked',
+            reason: includeGenerated
+                ? undefined
+                : 'unpromoted generated tests — pass --include-generated to remove',
+            sizeBytes: (0, uninstall_types_js_1.dirSize)(generated),
+        });
+    }
+    // `.mcp.json` is shared with other servers, so only our key comes out.
+    const mcpPath = path.join(cwd, '.mcp.json');
+    const mcp = (0, uninstall_types_js_1.readJson)(mcpPath);
+    if (mcp?.mcpServers && Object.hasOwn(mcp.mcpServers, uninstall_types_js_1.MCP_KEY)) {
+        found.push({
+            scope: 'project',
+            kind: 'mcp-entry',
+            label: `.mcp.json → "${uninstall_types_js_1.MCP_KEY}" server entry`,
+            path: mcpPath,
+            disposition: 'removable',
+        });
+    }
+    return found;
+}
+function enumerate(opts, deps = {}) {
+    const out = [];
+    if (opts.scope === 'global' || opts.scope === 'all') {
+        out.push(...enumerateGlobal(opts, deps));
+    }
+    if (opts.scope === 'project' || opts.scope === 'all') {
+        out.push(...enumerateProject(opts, deps));
+    }
+    return out;
+}
+/**
+ * Remove `.canary/` while preserving the quarantine ledger when it was not
+ * opted into. Deleting the directory wholesale would take the ledger with it,
+ * silently undoing the protection the `blocked` disposition just promised.
+ */

package/dist/uninstall-types.d.ts

@@ -0,0 +1,46 @@
+export declare const MARKETPLACE = "bop-clocktower";
+export declare const PLUGIN_KEY = "canary@bop-clocktower";
+export declare const MCP_KEY = "canary-mcp";
+export type Scope = 'global' | 'project' | 'all';
+/**
+ * `removable` — the CLI will delete it under `--apply`.
+ * `blocked`   — found, deliberately not removed; `reason` says why.
+ * `manual`    — someone else owns it; `reason` carries the exact command.
+ */
+export type Disposition = 'removable' | 'blocked' | 'manual';
+export interface Artifact {
+    scope: 'global' | 'project';
+    kind: string;
+    label: string;
+    path: string | null;
+    disposition: Disposition;
+    reason?: string;
+    sizeBytes?: number;
+}
+export interface EnumerateOptions {
+    scope: Scope;
+    includeGenerated?: boolean;
+}
+export type GitRunner = (args: string[], opts?: {
+    cwd?: string;
+}) => {
+    status: number | null;
+    stdout: string;
+    stderr: string;
+};
+export interface Writer {
+    write: (s: string) => void;
+}
+export interface UninstallDeps {
+    homeDir?: string;
+    cwd?: string;
+    out?: Writer;
+    err?: Writer;
+    git?: GitRunner;
+    /** Resolved path of the running CLI, injectable for tests. */
+    cliPath?: string;
+}
+export declare const defaultGit: GitRunner;
+export declare function readJson(file: string): unknown;
+/** Recursive byte size; best-effort, never throws. */
+export declare function dirSize(target: string): number;

package/dist/uninstall-types.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultGit = exports.MCP_KEY = exports.PLUGIN_KEY = exports.MARKETPLACE = void 0;
+exports.readJson = readJson;
+exports.dirSize = dirSize;
+/**
+ * Shared vocabulary for `canary uninstall`: the artifact model every phase
+ * speaks, plus the filesystem helpers the scan needs. Split out so the scan,
+ * render, and removal modules each stay independently readable.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+exports.MARKETPLACE = 'bop-clocktower';
+exports.PLUGIN_KEY = 'canary@bop-clocktower';
+exports.MCP_KEY = 'canary-mcp';
+const defaultGit = (args, opts = {}) => {
+    const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: opts.cwd, encoding: 'utf8' });
+    return { status: r.status, stdout: r.stdout ?? '', stderr: r.stderr ?? '' };
+};
+exports.defaultGit = defaultGit;
+function readJson(file) {
+    try {
+        return JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Recursive byte size; best-effort, never throws. */
+function dirSize(target) {
+    let total = 0;
+    const walk = (p) => {
+        let st;
+        try {
+            st = fs.statSync(p);
+        }
+        catch {
+            return;
+        }
+        if (st.isDirectory()) {
+            let kids = [];
+            try {
+                kids = fs.readdirSync(p);
+            }
+            catch {
+                return;
+            }
+            for (const k of kids)
+                walk(path.join(p, k));
+        }
+        else {
+            total += st.size;
+        }
+    };
+    walk(target);
+    return total;
+}

package/dist/uninstall.d.ts

@@ -0,0 +1,13 @@
+import { type Artifact, type UninstallDeps } from './uninstall-types.js';
+export { enumerate } from './uninstall-scan.js';
+export { render } from './uninstall-render.js';
+export type { Artifact, Disposition, EnumerateOptions, Scope, UninstallDeps, } from './uninstall-types.js';
+export interface RemovalOutcome {
+    removed: Artifact[];
+    failed: Array<{
+        artifact: Artifact;
+        error: string;
+    }>;
+}
+export declare function removeAll(artifacts: Artifact[], deps?: UninstallDeps): RemovalOutcome;
+export declare function run(argv: readonly string[], deps?: UninstallDeps): number;