@hunchoweb/nclean 0.0.0-stage → 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,30 @@
+export type PackageManager = 'npm' | 'pnpm' | 'yarn' | 'bun';
+export interface Candidate {
+    project: string;
+    path: string;
+    root: string;
+    manager: PackageManager;
+    lastActive: number | null;
+    bytes: number | null;
+    device: number;
+    inode: number;
+    error: string | null;
+}
+export interface ScanResult {
+    projects: number;
+    entries: Candidate[];
+    warnings: string[];
+}
+export interface Options {
+    olderThan?: number;
+    dryRun?: boolean;
+    yes?: boolean;
+    verbose?: boolean;
+}
+export interface ScanProgress {
+    phase: 'discovery' | 'measurement';
+    projects: number;
+    folders: number;
+    completed: number;
+    total: number | null;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/diagnostics.d.ts

@@ -0,0 +1,2 @@
+import type { Candidate } from '../types.js';
+export declare function scanDiagnostics(warnings: string[], entries: Candidate[], verbose?: boolean): string;

package/dist/ui/diagnostics.js

@@ -0,0 +1,27 @@
+import { terminalText } from '../utils/format.js';
+import { textLines } from './layout.js';
+import pc from 'picocolors';
+export function scanDiagnostics(warnings, entries, verbose = false) {
+    const unreadable = entries.filter(entry => entry.error);
+    if (!warnings.length && !unreadable.length)
+        return '';
+    const restricted = warnings.filter(value => /\b(?:EPERM|EACCES):/.test(value)).length;
+    const lines = [];
+    if (warnings.length) {
+        const other = warnings.length - restricted;
+        const reasons = [restricted ? `${restricted} access denied` : '', other ? `${other} other ${other === 1 ? 'warning' : 'warnings'}` : ''].filter(Boolean).join(', ');
+        lines.push(`Partial scan · ${warnings.length} ${warnings.length === 1 ? 'folder' : 'folders'} skipped (${reasons}).`);
+    }
+    if (unreadable.length)
+        lines.push(`${unreadable.length} dependency ${unreadable.length === 1 ? 'folder is' : 'folders are'} unreadable and excluded from cleanup.`);
+    const result = [pc.yellow(textLines(lines.join('\n')))];
+    if (verbose) {
+        for (const value of warnings)
+            result.push(textLines(`Scan warning: ${terminalText(value)}`));
+        for (const entry of unreadable)
+            result.push(textLines(`${entry.path}: ${terminalText(entry.error)}`));
+    }
+    else
+        result.push(pc.dim(textLines('Use --verbose for details. Accessible projects are still shown.')));
+    return `${result.join('\n')}\n`;
+}

package/dist/ui/interactive.d.ts

@@ -0,0 +1,10 @@
+import type { Candidate } from '../types.js';
+export declare const isInteractive: () => boolean;
+interface SelectionConfig {
+    entries: Candidate[];
+}
+export declare const dependencyPrompt: import("@inquirer/type").Prompt<Candidate[], SelectionConfig>;
+export declare function selectEntries(entries: Candidate[]): Promise<Candidate[]>;
+export declare const cleanupPrompt: import("@inquirer/type").Prompt<boolean, Record<string, never>>;
+export declare function confirmCleanup(): Promise<boolean>;
+export {};

package/dist/ui/interactive.js

@@ -0,0 +1,88 @@
+import { createPrompt, useState, useKeypress, useEffect, isUpKey, isDownKey, isSpaceKey, isEnterKey, usePagination } from '@inquirer/core';
+import pc from 'picocolors';
+import { formatSize } from '../utils/format.js';
+import { rows, terminalWidth, keyboardHelp, truncate, textLines, frame } from './layout.js';
+export const isInteractive = () => Boolean(process.stdin.isTTY && process.stdout.isTTY);
+export const dependencyPrompt = createPrompt((config, done) => {
+    const [active, setActive] = useState(0);
+    const [selected, setSelected] = useState(new Set());
+    const [finished, setFinished] = useState(false);
+    const [cancelled, setCancelled] = useState(false);
+    const [width, setWidth] = useState(terminalWidth());
+    useEffect(() => {
+        const resize = () => setWidth(terminalWidth());
+        process.stdout.on('resize', resize);
+        return () => { process.stdout.off('resize', resize); };
+    }, []);
+    useKeypress(key => {
+        if (isUpKey(key))
+            setActive(Math.max(0, active - 1));
+        else if (isDownKey(key))
+            setActive(Math.min(config.entries.length - 1, active + 1));
+        else if (isSpaceKey(key)) {
+            const next = new Set(selected);
+            if (next.has(active))
+                next.delete(active);
+            else
+                next.add(active);
+            setSelected(next);
+        }
+        else if (key.name === 'a')
+            setSelected(selected.size === config.entries.length ? new Set() : new Set(config.entries.map((_, index) => index)));
+        else if (key.name === 'escape') {
+            setCancelled(true);
+            setFinished(true);
+            done([]);
+        }
+        else if (isEnterKey(key)) {
+            setFinished(true);
+            done(config.entries.filter((_, index) => selected.has(index)));
+        }
+    });
+    const layout = rows(config.entries, width - 6, 4);
+    const page = usePagination({
+        items: config.entries, active, loop: false,
+        pageSize: Math.max(1, Math.min(10, (process.stdout.rows || 24) - 15)),
+        renderItem: ({ item, index, isActive }) => {
+            const marker = selected.has(index) ? '●' : '○';
+            const cursor = isActive ? pc.cyan('›') : ' ';
+            return `${cursor} ${selected.has(index) ? pc.cyan(marker) : pc.dim(marker)} ${layout.render(item)}`;
+        },
+    });
+    const bytes = config.entries.reduce((sum, entry, index) => sum + (selected.has(index) ? entry.bytes ?? 0 : 0), 0);
+    const summary = `${selected.size} selected · ${formatSize(bytes)}`;
+    // Finish as one compact sentence, never a comma-joined list of paths.
+    if (finished)
+        return pc.dim(`  ${truncate(cancelled ? 'Selection cancelled' : summary, width - 3)}`);
+    const position = config.entries.length > 10 ? `  ${active + 1}/${config.entries.length}\n` : '';
+    return `  ${pc.bold(width < 40 ? 'Select dependencies' : 'Select dependencies to remove')}\n\n\n${frame(page.split('\n'), width, `    ${layout.header}`)}\n${position}\n\n  ${pc.cyan(pc.bold(truncate(summary, width - 3)))}\n\n\n${keyboardHelp(width)}\n`;
+});
+export async function selectEntries(entries) {
+    return dependencyPrompt({ entries });
+}
+// A restrained Yes / No prompt; default and initial focus are always No.
+export const cleanupPrompt = createPrompt((_config, done) => {
+    const [yes, setYes] = useState(false);
+    const [finished, setFinished] = useState(false);
+    useKeypress(key => {
+        if (key.name === 'left' || key.name === 'right' || key.name === 'tab' || isSpaceKey(key))
+            setYes(!yes);
+        else if (key.name === 'y')
+            setYes(true);
+        else if (key.name === 'n')
+            setYes(false);
+        else if (key.name === 'escape') {
+            setYes(false);
+            setFinished(true);
+            done(false);
+        }
+        else if (isEnterKey(key)) {
+            setFinished(true);
+            done(yes);
+        }
+    });
+    if (finished)
+        return `  ${pc.dim(`Continue? ${yes ? 'Yes' : 'No'}`)}`;
+    return `  ${pc.bold('Continue?')} [y/N] ${yes ? 'y' : ''}\n\n${pc.dim(textLines('[y] yes   [n] no   [enter] confirm', terminalWidth()))}`;
+});
+export async function confirmCleanup() { return cleanupPrompt({}); }

package/dist/ui/layout.d.ts

@@ -0,0 +1,14 @@
+import type { Candidate } from '../types.js';
+export declare const terminalWidth: () => number;
+export declare function truncate(value: string, width: number): string;
+export declare function pad(value: string, width: number, right?: boolean): string;
+export declare function compactRoot(root: string, width?: number): string;
+export declare function projectLabel(entry: Candidate, entries: Candidate[]): string;
+export declare function compactAge(time: number | null, now?: number): string;
+export declare function rows(entries: Candidate[], width?: number, prefixWidth?: number, metadata?: boolean): {
+    header: string;
+    render: (entry: Candidate) => string;
+};
+export declare function keyboardHelp(width?: number): string;
+export declare function textLines(value: string, width?: number): string;
+export declare function frame(lines: string[], width?: number, header?: string): string;

package/dist/ui/layout.js

@@ -0,0 +1,128 @@
+import path from 'node:path';
+import pc from 'picocolors';
+import stringWidth from 'string-width';
+import { displayPath } from '../utils/paths.js';
+import { DAY, formatSize, terminalText } from '../utils/format.js';
+export const terminalWidth = () => Math.max(8, Math.min(100, process.stdout.columns || 80));
+const graphemes = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+export function truncate(value, width) {
+    value = terminalText(value);
+    if (width <= 0)
+        return '';
+    if (stringWidth(value) <= width)
+        return value;
+    const marker = width > 3 ? '...' : '.'.repeat(width);
+    const remaining = width - marker.length;
+    const chars = [...graphemes.segment(value)].map(part => part.segment);
+    const take = (parts, budget) => {
+        let result = '';
+        for (const part of parts) {
+            if (stringWidth(result + part) > budget)
+                break;
+            result += part;
+        }
+        return result;
+    };
+    const start = take(chars, Math.ceil(remaining * 0.4));
+    const end = take(chars.toReversed(), remaining - stringWidth(start));
+    return start + marker + [...graphemes.segment(end)].map(part => part.segment).reverse().join('');
+}
+export function pad(value, width, right = false) {
+    const fitted = truncate(value, width);
+    const spaces = ' '.repeat(Math.max(0, width - stringWidth(fitted)));
+    return right ? spaces + fitted : fitted + spaces;
+}
+export function compactRoot(root, width = terminalWidth() - 4) {
+    const display = displayPath(root);
+    return truncate(display.startsWith('~') ? display : `.../${path.basename(root)}`, width);
+}
+export function projectLabel(entry, entries) {
+    const relative = path.relative(entry.root, entry.project).split(path.sep).join('/') || path.basename(entry.project);
+    const roots = [...new Set(entries.map(item => item.root))];
+    if (roots.length === 1)
+        return terminalText(relative);
+    const name = path.basename(entry.root);
+    const sameName = roots.filter(root => path.basename(root) === name).length > 1;
+    return terminalText(`${sameName ? `[${roots.indexOf(entry.root) + 1}]` : name}/${relative}`);
+}
+export function compactAge(time, now = Date.now()) {
+    if (time === null)
+        return 'unknown';
+    const days = Math.floor(Math.max(0, now - time) / DAY);
+    if (days >= 365)
+        return `${Math.floor(days / 365)}y`;
+    if (days >= 90)
+        return `${Math.floor(days / 30)}mo`;
+    return `${days}d`;
+}
+export function rows(entries, width = terminalWidth(), prefixWidth = 2, metadata = true) {
+    const space = Math.max(1, width - prefixWidth - 1); // Leave one cell to avoid terminal auto-wrap.
+    const showSize = space >= 20;
+    const showAge = metadata && space >= 38;
+    const showManager = metadata && space >= 54;
+    const sizeWidth = showSize ? entries.reduce((max, entry) => Math.max(max, stringWidth(entry.bytes === null ? 'unknown' : formatSize(entry.bytes))), 8) : 0;
+    const ageWidth = showAge ? entries.reduce((max, entry) => Math.max(max, stringWidth(compactAge(entry.lastActive))), 8) : 0;
+    const managerWidth = showManager ? 4 : 0;
+    const extra = [sizeWidth, ageWidth, managerWidth].filter(Boolean).reduce((sum, value) => sum + value + 3, 0);
+    const nameWidth = Math.max(1, Math.min(60, space - extra, entries.reduce((max, entry) => Math.max(max, stringWidth(projectLabel(entry, entries))), 22)));
+    const compose = (name, size, age, manager, styled) => {
+        const cells = [pad(name, nameWidth)];
+        if (showSize)
+            cells.push(pad(size, sizeWidth, true));
+        if (showAge)
+            cells.push(styled ? pc.dim(pad(age, ageWidth, true)) : pad(age, ageWidth, true));
+        if (showManager)
+            cells.push(styled ? pc.dim(pad(manager, managerWidth)) : pad(manager, managerWidth));
+        return cells.join('   ');
+    };
+    return {
+        header: pc.dim(compose('Project', 'Size', 'Inactive', 'PM', false)),
+        render: (entry) => compose(projectLabel(entry, entries), entry.bytes === null ? 'unknown' : formatSize(entry.bytes), compactAge(entry.lastActive), entry.manager, true),
+    };
+}
+export function keyboardHelp(width = terminalWidth()) {
+    const controls = ['[space] select', '[a] all', '[enter] clean', '[esc] cancel'];
+    const lines = [];
+    let line = '';
+    for (const control of controls) {
+        const next = line ? `${line}     ${control}` : control;
+        if (line && stringWidth(next) > width - 3) {
+            lines.push(line);
+            line = control;
+        }
+        else
+            line = next;
+    }
+    if (line)
+        lines.push(line);
+    return pc.dim(lines.map(value => `  ${truncate(value, width - 3)}`).join('\n'));
+}
+// Static prose wraps at word boundaries; project rows always remain a single line.
+export function textLines(value, width = terminalWidth()) {
+    const budget = Math.max(1, width - 3);
+    return value.split('\n').flatMap(paragraph => {
+        if (!paragraph)
+            return [''];
+        const lines = [];
+        let line = '';
+        for (const word of terminalText(paragraph).split(' ')) {
+            if (line && stringWidth(`${line} ${word}`) > budget) {
+                lines.push(`  ${line}`);
+                line = '';
+            }
+            const fitted = truncate(word, budget);
+            line = line ? `${line} ${fitted}` : fitted;
+        }
+        if (line)
+            lines.push(`  ${line}`);
+        return lines;
+    }).join('\n');
+}
+// One muted frame around a list, with a cell budget shared by all row renderers.
+export function frame(lines, width = terminalWidth(), header) {
+    const boxWidth = Math.max(5, width - 3);
+    const inner = boxWidth - 4;
+    const edge = (left, right) => `  ${pc.dim(`${left}${'─'.repeat(boxWidth - 2)}${right}`)}`;
+    const line = (content) => `  ${pc.dim('│')} ${content}${' '.repeat(Math.max(0, inner - stringWidth(content)))} ${pc.dim('│')}`;
+    return [edge('┌', '┐'), ...(header ? [line(header), edge('├', '┤')] : []), ...lines.map(line), edge('└', '┘')].join('\n');
+}

package/dist/ui/output.d.ts

@@ -0,0 +1,13 @@
+import type { Candidate } from '../types.js';
+export declare function banner(): void;
+export declare function total(entries: Candidate[]): number;
+export declare function message(title: string, detail: string, tip?: string): void;
+export declare function note(value: string): void;
+export declare function warning(value: string): void;
+export declare function scanning(roots: string[]): void;
+export declare function scanComplete(projects: number, folders: number, entries: Candidate[], filtered: boolean): void;
+export declare function table(entries: Candidate[], minimal?: boolean): void;
+export declare function plan(entries: Candidate[]): void;
+export declare function cleanupComplete(removed: Candidate[], bytes: number, failed: number): void;
+export declare function restores(entries: Candidate[]): void;
+export declare function deletionFailure(entry: Candidate, entries: Candidate[], reason: string): void;

package/dist/ui/output.js

@@ -0,0 +1,72 @@
+import pc from 'picocolors';
+import { formatSize, terminalText } from '../utils/format.js';
+import { compactRoot, projectLabel, rows, terminalWidth, textLines, truncate, frame } from './layout.js';
+import { wordmark, sizeHero } from './typography.js';
+export function banner() {
+    console.log(`\n${pc.cyan(wordmark().map(line => `  ${line}`).join('\n'))}\n\n${pc.dim(textLines('Node modules cleanup, without the drama.'))}\n\n`);
+}
+export function total(entries) { return entries.reduce((sum, entry) => sum + (entry.bytes ?? 0), 0); }
+export function message(title, detail, tip) {
+    const heading = title.toLowerCase().replace(/^./, char => char.toUpperCase());
+    console.log(`\n${pc.bold(textLines(`${heading}.`))}\n\n${textLines(detail)}${tip ? `\n\n${pc.dim(textLines(tip))}` : ''}\n\n`);
+}
+export function note(value) { console.log(pc.dim(textLines(value))); }
+export function warning(value) { console.error(textLines(value)); }
+export function scanning(roots) {
+    if (roots.length === 1)
+        console.log(textLines(`Scanning ${compactRoot(roots[0], terminalWidth() - 15)}...`));
+    else {
+        console.log(textLines('Scanning projects...'));
+        for (const [index, root] of roots.entries())
+            note(`[${index + 1}] ${compactRoot(root, terminalWidth() - 8)}`);
+    }
+    console.log('\n');
+}
+export function scanComplete(projects, folders, entries, filtered) {
+    const eligible = entries.filter(entry => entry.bytes !== null && entry.lastActive !== null && !entry.error);
+    console.log(textLines(`${projects} ${projects === 1 ? 'project' : 'projects'} scanned`));
+    note(`${folders} dependency ${folders === 1 ? 'folder' : 'folders'} found`);
+    if (eligible.length) {
+        console.log(textLines(`${eligible.length} ${filtered ? 'inactive ' : 'eligible '}${eligible.length === 1 ? 'project' : 'projects'}`));
+        console.log(`\n${pc.cyan(pc.bold(textLines(`${formatSize(total(eligible))} reclaimable`)))}`);
+    }
+    console.log('\n');
+}
+export function table(entries, minimal = false) {
+    const layout = rows(entries, terminalWidth() - 6, 0, !minimal);
+    // Read-only reports need headings. Selection and confirmation rely on spacing.
+    console.log(frame(entries.map(entry => layout.render(entry)), terminalWidth(), minimal ? undefined : layout.header));
+    console.log('\n');
+}
+export function plan(entries) {
+    console.log(`\n${pc.yellow(pc.bold(textLines('Ready to clean.')))}\n\n`);
+    console.log(textLines(`${entries.length} node_modules ${entries.length === 1 ? 'directory' : 'directories'}`));
+    console.log(pc.bold(textLines(formatSize(total(entries)))));
+    console.log('\n');
+    table(entries, true);
+    note('Only node_modules in the listed projects will be removed.');
+    note('Your project files and lockfiles will not be touched.');
+    console.log('\n');
+}
+export function cleanupComplete(removed, bytes, failed) {
+    console.log(`\n${pc.bold(textLines(failed ? 'Cleanup finished with errors.' : 'Cleanup complete.'))}\n`);
+    console.log(removed.length ? pc.green(sizeHero(formatSize(bytes))) : sizeHero(formatSize(bytes)));
+    console.log(textLines(`${removed.length} node_modules removed${failed ? ` · ${failed} failed` : ''}`));
+    note(`${removed.length} ${removed.length === 1 ? 'project' : 'projects'} untouched`);
+    console.log('\n');
+}
+export function restores(entries) {
+    note('Restore dependencies whenever you need them.');
+    console.log();
+    for (const manager of [...new Set(entries.map(entry => entry.manager))]) {
+        console.log(`    ${pc.bold(`${manager} install`)}`);
+        for (const entry of entries.filter(entry => entry.manager === manager))
+            console.log(pc.dim(`      ${truncate(projectLabel(entry, entries), terminalWidth() - 7)}`));
+        console.log();
+    }
+    console.log(`\n${textLines('Done.')}\n`);
+}
+export function deletionFailure(entry, entries, reason) {
+    console.error(pc.red(textLines(`Could not remove ${projectLabel(entry, entries)}/node_modules`)));
+    console.error(pc.dim(textLines(`Reason: ${terminalText(reason)}`)));
+}

package/dist/ui/progress.d.ts

@@ -0,0 +1,11 @@
+import type { ScanProgress } from '../types.js';
+export declare function progressBar(percent: number | null, width?: number, step?: number): string;
+export declare function progressPercent(state: ScanProgress): number | null;
+export declare function startScanProgress(): {
+    update: (state: ScanProgress) => void;
+    stop: () => void;
+};
+export declare function startCleanupProgress(total: number): {
+    update: (completed: number, failed: number) => void;
+    stop: () => void;
+};

package/dist/ui/progress.js

@@ -0,0 +1,75 @@
+import ora from 'ora';
+import pc from 'picocolors';
+import { terminalWidth, truncate } from './layout.js';
+export function progressBar(percent, width = 80, step = 0) {
+    const length = Math.max(4, Math.min(32, width - 18));
+    if (percent !== null) {
+        const filled = Math.round(length * Math.max(0, Math.min(100, percent)) / 100);
+        return '█'.repeat(filled) + '░'.repeat(length - filled);
+    }
+    const segment = Math.min(5, Math.max(1, Math.floor(length / 3)));
+    const travel = Math.max(1, length - segment);
+    const offset = travel - Math.abs((step % (travel * 2)) - travel);
+    return '░'.repeat(offset) + '█'.repeat(segment) + '░'.repeat(length - segment - offset);
+}
+export function progressPercent(state) {
+    return state.phase === 'measurement' && state.total !== null && state.total > 0
+        ? Math.floor(state.completed / state.total * 100) : null;
+}
+function startProgress(initial) {
+    let current = initial;
+    let frameKey = '';
+    const spinner = ora({ indent: 2, color: 'cyan', isEnabled: Boolean(process.stderr.isTTY), isSilent: !process.stderr.isTTY });
+    const update = (state) => {
+        current = state;
+        const width = terminalWidth();
+        const percent = state.percent;
+        const key = `${width}:${percent}`;
+        if (key !== frameKey) {
+            spinner.spinner = {
+                interval: 180,
+                frames: percent === null
+                    ? Array.from({ length: 56 }, (_, index) => progressBar(null, width, index))
+                    : [progressBar(percent, width)],
+            };
+            frameKey = key;
+        }
+        const label = percent === null ? ' discovering' : ` ${pc.bold(`${percent}%`)}`;
+        spinner.text = `${label}\n\n  ${pc.dim(truncate(state.detail(width), width - 6))}`;
+    };
+    update(current);
+    spinner.start();
+    const resize = () => update(current);
+    process.stdout.on('resize', resize);
+    return {
+        update,
+        stop: () => {
+            process.stdout.off('resize', resize);
+            if (spinner.isSpinning && current.percent === 100) {
+                spinner.stopAndPersist({ symbol: pc.cyan(progressBar(100, terminalWidth())), text: pc.bold('100%') });
+            }
+            else
+                spinner.stop();
+            if (process.stderr.isTTY)
+                console.log();
+        },
+    };
+}
+export function startScanProgress() {
+    const view = (state) => ({
+        percent: progressPercent(state),
+        detail: width => state.phase === 'discovery'
+            ? (width < 48 ? `${state.projects} projects, ${state.folders} dirs` : `${state.projects} projects · ${state.folders} dependency folders`)
+            : `${state.completed}/${state.total} ${width < 48 ? 'measured' : 'dependency folders measured'}`,
+    });
+    const progress = startProgress(view({ phase: 'discovery', projects: 0, folders: 0, completed: 0, total: null }));
+    return { update: state => progress.update(view(state)), stop: progress.stop };
+}
+export function startCleanupProgress(total) {
+    const view = (completed, failed) => ({
+        percent: total > 0 ? Math.floor(completed / total * 100) : 100,
+        detail: width => `${width < 48 ? 'Cleaning' : 'Cleaning dependencies'} · ${completed}/${total} processed${failed ? ` · ${failed} failed` : ''}`,
+    });
+    const progress = startProgress(view(0, 0));
+    return { update: (completed, failed) => progress.update(view(completed, failed)), stop: progress.stop };
+}

package/dist/ui/typography.d.ts

@@ -0,0 +1,2 @@
+export declare function wordmark(width?: number): string[];
+export declare function sizeHero(size: string, width?: number): string;

package/dist/ui/typography.js

@@ -0,0 +1,40 @@
+import pc from 'picocolors';
+import stringWidth from 'string-width';
+import { terminalWidth, textLines } from './layout.js';
+// Outlined, slanted letterforms: each stroke has two visible edges.
+const outlined = {
+    n: ['        ', '  ____  ', ' / __ \\ ', '/ / / / ', '/_/ /_/ '],
+    c: ['        ', '  _____ ', ' / ___/ ', '/ /__   ', '\\____/  '],
+    l: ['   __   ', '  / /   ', ' / /    ', '/ /__   ', '\\___/   '],
+    e: ['        ', '  ____  ', ' / __ \\ ', '/ ____/ ', '\\___/   '],
+    a: ['        ', '  ____  ', ' / __ | ', '/ /_/ / ', '\\__,_/  '],
+};
+export function wordmark(width = terminalWidth()) {
+    if (width < 50)
+        return ['nclean'];
+    const gap = width >= 60 ? '  ' : '';
+    return outlined.n.map((_, row) => [...'nclean'].map(char => outlined[char][row].trimEnd().padEnd(7)).join(gap).trimEnd());
+}
+const digits = {
+    '0': [' _ ', '| |', '|_|'], '1': ['   ', '  |', '  |'],
+    '2': [' _ ', ' _|', '|_ '], '3': [' _ ', ' _|', ' _|'],
+    '4': ['   ', '|_|', '  |'], '5': [' _ ', '|_ ', ' _|'],
+    '6': [' _ ', '|_ ', '|_|'], '7': [' _ ', '  |', '  |'],
+    '8': [' _ ', '|_|', '|_|'], '9': [' _ ', '|_|', ' _|'],
+    '.': [' ', ' ', '.'],
+};
+export function sizeHero(size, width = terminalWidth()) {
+    const [value = '', unit = ''] = size.split(' ');
+    const glyphs = [...value].map(char => digits[char]);
+    const art = glyphs.every(Boolean) ? [0, 1, 2].map(row => glyphs.map(glyph => glyph[row]).join(' ')) : [];
+    // The unit stays in native type, aligned with the enlarged number's baseline.
+    const artWidth = art.length ? stringWidth(`${art[2]}  ${unit}`) : Infinity;
+    const column = Math.min(64, width - 4);
+    if (width < 48 || artWidth > column)
+        return `\n${pc.bold(textLines(size, width))}\n${pc.dim(textLines('space reclaimed', width))}\n`;
+    const indent = ' '.repeat(2 + Math.floor((column - artWidth) / 2));
+    const lines = art.map((line, row) => pc.bold(`${indent}${line}${row === 2 ? `  ${unit}` : ''}`));
+    const caption = 'space reclaimed';
+    const captionIndent = ' '.repeat(2 + Math.max(0, Math.floor((column - caption.length) / 2)));
+    return `\n${lines.join('\n')}\n\n${pc.dim(`${captionIndent}${caption}`)}\n`;
+}

package/dist/utils/format.d.ts

@@ -0,0 +1,6 @@
+export declare const DAY = 86400000;
+export declare function formatSize(bytes: number): string;
+export declare function formatAge(time: number | null, now?: number): string;
+export declare function oldEnough(time: number | null, days: number, now?: number): boolean;
+export declare function errorMessage(error: unknown): string;
+export declare function terminalText(value: string): string;

package/dist/utils/format.js

@@ -0,0 +1,24 @@
+export const DAY = 86_400_000;
+export function formatSize(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB'];
+    let i = 0;
+    while (bytes >= 1024 && i < units.length - 1) {
+        bytes /= 1024;
+        i++;
+    }
+    return `${bytes < 100 && i > 0 ? bytes.toFixed(1) : Math.round(bytes)} ${units[i]}`;
+}
+export function formatAge(time, now = Date.now()) {
+    if (time === null)
+        return 'unknown';
+    const days = Math.floor(Math.max(0, now - time) / DAY);
+    return days === 0 ? 'today' : `${days} day${days === 1 ? '' : 's'} ago`;
+}
+export function oldEnough(time, days, now = Date.now()) {
+    return time !== null && now - time >= days * DAY;
+}
+export function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+// Prevent filenames from injecting terminal escape sequences or extra rows.
+export function terminalText(value) { return value.replace(/[\x00-\x1f\x7f-\x9f]/g, '?'); }

package/dist/utils/package-manager.d.ts

@@ -0,0 +1,3 @@
+import type { PackageManager } from '../types.js';
+export declare const lockfiles: [string, PackageManager][];
+export declare function detectManager(project: string): Promise<PackageManager>;

package/dist/utils/package-manager.js

@@ -0,0 +1,18 @@
+import { lstat } from 'node:fs/promises';
+import path from 'node:path';
+export const lockfiles = [
+    ['pnpm-lock.yaml', 'pnpm'], ['yarn.lock', 'yarn'], ['bun.lock', 'bun'], ['bun.lockb', 'bun'], ['package-lock.json', 'npm'], ['npm-shrinkwrap.json', 'npm'],
+];
+export async function detectManager(project) {
+    for (const [file, manager] of lockfiles) {
+        try {
+            if ((await lstat(path.join(project, file))).isFile())
+                return manager;
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+        }
+    }
+    return 'npm';
+}

package/dist/utils/paths.d.ts

@@ -0,0 +1,5 @@
+export declare function expandPath(input: string): string;
+export declare function within(root: string, target: string): boolean;
+export declare function displayPath(value: string): string;
+export declare function scanRoots(inputs: string[]): Promise<string[]>;
+export declare function assertRealPath(root: string, target: string): Promise<void>;

package/dist/utils/paths.js

@@ -0,0 +1,48 @@
+import path from 'node:path';
+import os from 'node:os';
+import { lstat, realpath } from 'node:fs/promises';
+import { terminalText } from './format.js';
+export function expandPath(input) {
+    if (input === '~')
+        return os.homedir();
+    return path.resolve(input.startsWith('~/') || input.startsWith('~\\') ? path.join(os.homedir(), input.slice(2)) : input);
+}
+export function within(root, target) {
+    const relative = path.relative(root, target);
+    return relative === '' || (!relative.startsWith(`..${path.sep}`) && relative !== '..' && !path.isAbsolute(relative));
+}
+export function displayPath(value) {
+    const home = os.homedir();
+    return terminalText(within(home, value) ? `~${value.slice(home.length)}` : value);
+}
+export async function scanRoots(inputs) {
+    const roots = [];
+    for (const input of inputs.length ? inputs : [process.cwd()]) {
+        const resolved = expandPath(input);
+        const stat = await lstat(resolved);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error(`Scan root must be a real directory: ${displayPath(resolved)}`);
+        const canonical = await realpath(resolved);
+        if (canonical === path.parse(canonical).root)
+            throw new Error('Scanning the filesystem root is not supported. Choose a project directory.');
+        if (canonical.split(path.sep).includes('node_modules'))
+            throw new Error('Choose a project directory, not a directory inside node_modules.');
+        roots.push(canonical);
+    }
+    return [...new Set(roots)].filter(root => !roots.some(other => other !== root && within(other, root)));
+}
+export async function assertRealPath(root, target) {
+    if (!within(root, target))
+        throw new Error('Path is outside the scan root.');
+    let current = root;
+    const parts = path.relative(root, target).split(path.sep).filter(Boolean);
+    for (const part of ['', ...parts]) {
+        if (part)
+            current = path.join(current, part);
+        const stat = await lstat(current);
+        if (!stat.isDirectory() || stat.isSymbolicLink())
+            throw new Error(`Directory changed or is a symlink: ${displayPath(current)}`);
+    }
+    if (await realpath(target) !== target)
+        throw new Error('Path resolves through a symlink.');
+}