@tukuyomil032/broom 1.0.0

package/dist/commands/purge.js

@@ -0,0 +1,271 @@
+/**
+ * Purge command - Clean project-specific artifacts
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { stat, rm } from 'fs/promises';
+import { basename } from 'path';
+import fg from 'fast-glob';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { getSize, formatSize, expandPath } from '../utils/fs.js';
+import { printHeader, success, warning, error, info, separator, createSpinner, succeedSpinner, printProgressBar, } from '../ui/output.js';
+import { confirmAction, selectItems } from '../ui/prompts.js';
+import { debug, debugSection, debugObj } from '../utils/debug.js';
+/**
+ * Project artifact targets
+ */
+const purgeTargets = [
+    {
+        id: 'node_modules',
+        name: 'Node.js (node_modules)',
+        patterns: ['**/node_modules'],
+        description: 'npm/yarn/pnpm packages',
+    },
+    {
+        id: 'build',
+        name: 'Build outputs (dist, build)',
+        patterns: ['**/dist', '**/build', '**/out', '**/.next', '**/.nuxt'],
+        description: 'Compiled/bundled files',
+    },
+    {
+        id: 'cache',
+        name: 'Project caches',
+        patterns: ['**/.cache', '**/.parcel-cache', '**/.turbo', '**/.eslintcache'],
+        description: 'Build and tool caches',
+    },
+    {
+        id: 'coverage',
+        name: 'Test coverage',
+        patterns: ['**/coverage', '**/.nyc_output'],
+        description: 'Code coverage reports',
+    },
+    {
+        id: 'python',
+        name: 'Python artifacts',
+        patterns: [
+            '**/__pycache__',
+            '**/*.pyc',
+            '**/.pytest_cache',
+            '**/.mypy_cache',
+            '**/venv',
+            '**/.venv',
+        ],
+        description: 'Python caches and venvs',
+    },
+    {
+        id: 'rust',
+        name: 'Rust (target)',
+        patterns: ['**/target'],
+        description: 'Cargo build artifacts',
+    },
+    {
+        id: 'java',
+        name: 'Java/Gradle/Maven',
+        patterns: ['**/.gradle', '**/build', '**/target'],
+        description: 'Java build artifacts',
+    },
+    {
+        id: 'ios',
+        name: 'iOS/Xcode',
+        patterns: ['**/DerivedData', '**/Pods', '**/.build'],
+        description: 'Xcode build data and CocoaPods',
+    },
+    {
+        id: 'logs',
+        name: 'Log files',
+        patterns: ['**/*.log', '**/logs', '**/.logs'],
+        description: 'Application logs',
+    },
+    {
+        id: 'temp',
+        name: 'Temporary files',
+        patterns: ['**/.tmp', '**/tmp', '**/*.tmp', '**/*.temp'],
+        description: 'Temporary files',
+    },
+];
+/**
+ * Find matching items for a target
+ */
+async function findTargetItems(basePath, target, recursive) {
+    const items = [];
+    for (const pattern of target.patterns) {
+        const searchPattern = recursive ? pattern : pattern.replace('**/', '');
+        try {
+            const matches = await fg(searchPattern, {
+                cwd: basePath,
+                absolute: true,
+                onlyDirectories: !pattern.includes('*.*'),
+                dot: true,
+                ignore: ['**/node_modules/**/node_modules'], // Avoid nested node_modules
+            });
+            for (const match of matches) {
+                try {
+                    const stats = await stat(match);
+                    const size = await getSize(match);
+                    items.push({
+                        path: match,
+                        name: basename(match),
+                        size,
+                        isDirectory: stats.isDirectory(),
+                        modifiedAt: stats.mtime,
+                    });
+                }
+                catch {
+                    // Skip if cannot access
+                }
+            }
+        }
+        catch {
+            // Pattern match error
+        }
+    }
+    // Deduplicate by path
+    const seen = new Set();
+    return items.filter((item) => {
+        if (seen.has(item.path)) {
+            return false;
+        }
+        seen.add(item.path);
+        return true;
+    });
+}
+/**
+ * Execute purge command
+ */
+export async function purgeCommand(options) {
+    const isDryRun = options.dryRun || false;
+    const basePath = options.path ? expandPath(options.path) : process.cwd();
+    const recursive = options.recursive ?? true;
+    debugSection('Purge Command');
+    debugObj('Options', options);
+    debug(`Base path: ${basePath}`);
+    debug(`Recursive: ${recursive}`);
+    printHeader(isDryRun ? '🧹 Purge Project Artifacts (Dry Run)' : '🧹 Purge Project Artifacts');
+    console.log(`Scanning: ${chalk.cyan(basePath)}`);
+    console.log(`Mode: ${recursive ? 'Recursive' : 'Current directory only'}`);
+    console.log();
+    // Select targets
+    const targetChoices = purgeTargets.map((t) => ({
+        name: t.name,
+        value: t.id,
+        description: t.description,
+    }));
+    const selectedIds = await selectItems('Select artifact types to purge:', targetChoices);
+    if (selectedIds.length === 0) {
+        warning('No targets selected');
+        return;
+    }
+    const selectedTargets = purgeTargets.filter((t) => selectedIds.includes(t.id));
+    // Scan for items
+    console.log();
+    const spinner = createSpinner('Scanning for artifacts...');
+    const allItems = new Map();
+    let totalSize = 0;
+    let totalCount = 0;
+    for (const target of selectedTargets) {
+        const items = await findTargetItems(basePath, target, recursive);
+        if (items.length > 0) {
+            allItems.set(target.id, items);
+            totalCount += items.length;
+            totalSize += items.reduce((sum, i) => sum + i.size, 0);
+        }
+    }
+    succeedSpinner(spinner, `Found ${totalCount} items (${formatSize(totalSize)})`);
+    if (totalCount === 0) {
+        console.log();
+        success('No artifacts found to purge!');
+        return;
+    }
+    // Show found items
+    console.log();
+    console.log(chalk.bold('Found artifacts:'));
+    console.log();
+    for (const [targetId, items] of allItems) {
+        const target = purgeTargets.find((t) => t.id === targetId);
+        const targetSize = items.reduce((sum, i) => sum + i.size, 0);
+        console.log(chalk.bold(`  ${target.name}`));
+        console.log(`    Items: ${items.length}  Size: ${chalk.yellow(formatSize(targetSize))}`);
+        // Show first few items
+        for (const item of items.slice(0, 3)) {
+            const relativePath = item.path.replace(basePath, '.');
+            console.log(`      ${chalk.dim(relativePath)} ${chalk.dim(`(${formatSize(item.size)})`)}`);
+        }
+        if (items.length > 3) {
+            console.log(chalk.dim(`      ... and ${items.length - 3} more`));
+        }
+        console.log();
+    }
+    // Confirm
+    if (!options.yes) {
+        console.log();
+        const confirmed = await confirmAction(`${isDryRun ? 'Simulate' : 'Purge'} ${totalCount} items (${formatSize(totalSize)})?`, false);
+        if (!confirmed) {
+            warning('Purge cancelled');
+            return;
+        }
+    }
+    // Execute purge
+    console.log();
+    separator();
+    let removedCount = 0;
+    let removedSize = 0;
+    const errors = [];
+    const allItemsFlat = Array.from(allItems.values()).flat();
+    for (let i = 0; i < allItemsFlat.length; i++) {
+        const item = allItemsFlat[i];
+        const progress = ((i + 1) / allItemsFlat.length) * 100;
+        printProgressBar(progress, 30, `Purging: ${basename(item.path)}`);
+        if (!isDryRun) {
+            try {
+                await rm(item.path, { recursive: true, force: true });
+                removedCount++;
+                removedSize += item.size;
+            }
+            catch (err) {
+                errors.push(`${item.path}: ${err.message}`);
+            }
+        }
+        else {
+            removedCount++;
+            removedSize += item.size;
+        }
+    }
+    // Clear progress line
+    process.stdout.write('\r' + ' '.repeat(80) + '\r');
+    // Summary
+    console.log();
+    separator();
+    console.log();
+    console.log(chalk.bold(isDryRun ? '🧪 Dry Run Complete' : '✨ Purge Complete'));
+    console.log();
+    console.log(`  Items ${isDryRun ? 'would be ' : ''}removed: ${chalk.green(removedCount)}`);
+    console.log(`  Space ${isDryRun ? 'would be ' : ''}freed: ${chalk.green(formatSize(removedSize))}`);
+    if (errors.length > 0) {
+        console.log(`  ${chalk.red(`Errors: ${errors.length}`)}`);
+        console.log();
+        errors.slice(0, 5).forEach((err) => error(err));
+        if (errors.length > 5) {
+            console.log(chalk.dim(`  ... and ${errors.length - 5} more errors`));
+        }
+    }
+    if (isDryRun) {
+        console.log();
+        info('This was a dry run. No files were deleted.');
+        info('Run without --dry-run to actually purge artifacts.');
+    }
+}
+/**
+ * Create purge command
+ */
+export function createPurgeCommand() {
+    const cmd = new Command('purge')
+        .description('Clean project-specific build artifacts')
+        .option('-n, --dry-run', 'Preview only, no deletions')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .option('-p, --path <path>', 'Path to scan (default: current directory)')
+        .option('--no-recursive', 'Only scan current directory')
+        .action(async (options) => {
+        await purgeCommand(options);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/remove.js

@@ -0,0 +1,184 @@
+/**
+ * remove command - Uninstall broom from the system
+ */
+import { Command } from 'commander';
+import { execSync } from 'child_process';
+import { existsSync, rmSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import chalk from 'chalk';
+import ora from 'ora';
+import { confirm } from '@inquirer/prompts';
+import { enhanceCommandHelp } from '../utils/help.js';
+const CONFIG_DIR = join(homedir(), '.config', 'broom');
+const CACHE_DIR = join(homedir(), '.cache', 'broom');
+const DATA_DIR = join(homedir(), '.local', 'share', 'broom');
+/**
+ * Detect how broom was installed
+ */
+function detectInstallMethod() {
+    try {
+        // Check if installed globally via npm/yarn/pnpm
+        const npmList = execSync('npm list -g --depth=0 2>/dev/null', { encoding: 'utf-8' });
+        if (npmList.includes('broom')) {
+            return 'npm';
+        }
+    }
+    catch { }
+    try {
+        const yarnList = execSync('yarn global list 2>/dev/null', { encoding: 'utf-8' });
+        if (yarnList.includes('broom')) {
+            return 'yarn';
+        }
+    }
+    catch { }
+    try {
+        const pnpmList = execSync('pnpm list -g 2>/dev/null', { encoding: 'utf-8' });
+        if (pnpmList.includes('broom')) {
+            return 'pnpm';
+        }
+    }
+    catch { }
+    try {
+        const bunList = execSync('bun pm ls -g 2>/dev/null', { encoding: 'utf-8' });
+        if (bunList.includes('broom')) {
+            return 'bun';
+        }
+    }
+    catch { }
+    // Check if running from local development
+    const scriptPath = process.argv[1];
+    if (scriptPath && scriptPath.includes('/dist/index.js')) {
+        return 'local';
+    }
+    return 'unknown';
+}
+/**
+ * Get files/directories that would be removed
+ */
+function getRemovableItems(keepConfig) {
+    const items = [
+        { path: CACHE_DIR, exists: existsSync(CACHE_DIR), description: 'Cache directory' },
+        { path: DATA_DIR, exists: existsSync(DATA_DIR), description: 'Data directory' },
+    ];
+    if (!keepConfig) {
+        items.push({
+            path: CONFIG_DIR,
+            exists: existsSync(CONFIG_DIR),
+            description: 'Config directory',
+        });
+    }
+    return items;
+}
+/**
+ * Remove user data directories
+ */
+function removeUserData(keepConfig) {
+    let removed = 0;
+    if (existsSync(CACHE_DIR)) {
+        rmSync(CACHE_DIR, { recursive: true, force: true });
+        removed++;
+    }
+    if (existsSync(DATA_DIR)) {
+        rmSync(DATA_DIR, { recursive: true, force: true });
+        removed++;
+    }
+    if (!keepConfig && existsSync(CONFIG_DIR)) {
+        rmSync(CONFIG_DIR, { recursive: true, force: true });
+        removed++;
+    }
+    return removed;
+}
+/**
+ * Uninstall broom
+ */
+async function uninstallBroom(opts) {
+    console.log(chalk.bold('\n🗑️  Uninstall broom\n'));
+    const installMethod = detectInstallMethod();
+    const items = getRemovableItems(opts.keepConfig);
+    const existingItems = items.filter((i) => i.exists);
+    console.log(chalk.dim('Installation method: ') + installMethod);
+    console.log();
+    if (installMethod === 'local') {
+        console.log(chalk.yellow('broom appears to be running from a local development directory.'));
+        console.log(chalk.dim('To remove, simply delete the project directory.\n'));
+    }
+    if (existingItems.length > 0) {
+        console.log(chalk.bold('User data to be removed:'));
+        for (const item of existingItems) {
+            console.log(`  ${chalk.red('•')} ${item.description}: ${chalk.dim(item.path)}`);
+        }
+        console.log();
+    }
+    if (opts.keepConfig) {
+        console.log(chalk.dim('Configuration will be preserved.\n'));
+    }
+    if (!opts.yes) {
+        const confirmed = await confirm({
+            message: 'Are you sure you want to uninstall broom?',
+            default: false,
+        });
+        if (!confirmed) {
+            console.log(chalk.yellow('Uninstall cancelled'));
+            return;
+        }
+    }
+    // Remove user data first
+    if (existingItems.length > 0) {
+        const dataSpinner = ora('Removing user data...').start();
+        const removed = removeUserData(opts.keepConfig);
+        dataSpinner.succeed(`Removed ${removed} data ${removed === 1 ? 'directory' : 'directories'}`);
+    }
+    // Uninstall package
+    if (installMethod !== 'local' && installMethod !== 'unknown') {
+        const uninstallSpinner = ora(`Uninstalling broom via ${installMethod}...`).start();
+        try {
+            let cmd;
+            switch (installMethod) {
+                case 'npm':
+                    cmd = 'npm uninstall -g broom';
+                    break;
+                case 'yarn':
+                    cmd = 'yarn global remove broom';
+                    break;
+                case 'pnpm':
+                    cmd = 'pnpm remove -g broom';
+                    break;
+                case 'bun':
+                    cmd = 'bun remove -g broom';
+                    break;
+                default:
+                    cmd = 'npm uninstall -g broom';
+            }
+            execSync(cmd, { stdio: 'pipe' });
+            uninstallSpinner.succeed('broom uninstalled successfully');
+        }
+        catch (error) {
+            uninstallSpinner.fail('Failed to uninstall broom package');
+            if (error instanceof Error) {
+                console.error(chalk.red(error.message));
+            }
+            console.log(chalk.dim('\nTry running manually:'));
+            console.log(chalk.dim('  npm uninstall -g broom'));
+        }
+    }
+    console.log(chalk.green('\n👋 broom has been removed. Thanks for using broom!\n'));
+    // Remove shell completion
+    console.log(chalk.dim('Remember to remove any shell completion scripts you may have added:'));
+    console.log(chalk.dim('  - ~/.bashrc or ~/.bash_profile'));
+    console.log(chalk.dim('  - ~/.zshrc or ~/.zsh/completions/_broom'));
+    console.log(chalk.dim('  - ~/.config/fish/completions/broom.fish\n'));
+}
+/**
+ * Create remove command
+ */
+export function createRemoveCommand() {
+    const cmd = new Command('remove')
+        .description('Uninstall broom from the system')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .option('-k, --keep-config', 'Keep configuration files')
+        .action(async (opts) => {
+        await uninstallBroom(opts);
+    });
+    return enhanceCommandHelp(cmd);
+}

package/dist/commands/reports.js

@@ -0,0 +1,173 @@
+/**
+ * Reports command - Manage cleanup reports
+ */
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { enhanceCommandHelp } from '../utils/help.js';
+import { readdir, stat, unlink } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { exists, formatSize } from '../utils/fs.js';
+import { printHeader, success, warning, info, separator, createSpinner, succeedSpinner, } from '../ui/output.js';
+import { confirm } from '../ui/prompts.js';
+/**
+ * Get all report files
+ */
+async function getReportFiles() {
+    const reportsDir = join(homedir(), '.broom', 'reports');
+    if (!exists(reportsDir)) {
+        return [];
+    }
+    const files = [];
+    try {
+        const entries = await readdir(reportsDir);
+        for (const entry of entries) {
+            if (!entry.endsWith('.html'))
+                continue;
+            const filePath = join(reportsDir, entry);
+            const stats = await stat(filePath);
+            files.push({
+                path: filePath,
+                name: entry,
+                size: stats.size,
+                date: stats.mtime,
+            });
+        }
+        // Sort by date descending (newest first)
+        files.sort((a, b) => b.date.getTime() - a.date.getTime());
+        return files;
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * List all reports
+ */
+async function listReports() {
+    printHeader('📊 Cleanup Reports');
+    const files = await getReportFiles();
+    if (files.length === 0) {
+        info('No reports found');
+        console.log();
+        console.log(chalk.dim('Reports are created with: broom clean --report'));
+        return;
+    }
+    console.log(chalk.bold(`Found ${files.length} report(s):`));
+    console.log();
+    const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        const dateStr = file.date.toLocaleString('ja-JP');
+        const sizeStr = formatSize(file.size);
+        console.log(`  ${i + 1}. ${chalk.cyan(file.name)}`);
+        console.log(`     ${chalk.dim(`Date: ${dateStr} | Size: ${sizeStr}`)}`);
+    }
+    console.log();
+    separator();
+    console.log();
+    console.log(`Total size: ${chalk.yellow(formatSize(totalSize))}`);
+    console.log();
+    console.log(chalk.dim('To delete reports: broom reports clean'));
+}
+/**
+ * Clean all reports
+ */
+async function cleanReports(options) {
+    printHeader('🗑️  Clean Reports');
+    const files = await getReportFiles();
+    if (files.length === 0) {
+        info('No reports to delete');
+        return;
+    }
+    const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+    console.log(chalk.bold(`Found ${files.length} report(s) to delete`));
+    console.log(`Total size: ${chalk.yellow(formatSize(totalSize))}`);
+    console.log();
+    // Confirm deletion
+    if (!options.yes) {
+        const shouldDelete = await confirm({
+            message: `Delete all ${files.length} report file(s)?`,
+            default: false,
+        });
+        if (!shouldDelete) {
+            info('Cancelled');
+            return;
+        }
+    }
+    // Delete files
+    const spinner = createSpinner('Deleting reports...');
+    let deleted = 0;
+    let failed = 0;
+    for (const file of files) {
+        try {
+            await unlink(file.path);
+            deleted++;
+        }
+        catch {
+            failed++;
+        }
+    }
+    succeedSpinner(spinner, 'Deletion complete');
+    console.log();
+    success(`Deleted ${deleted} report(s)`);
+    console.log(`Freed space: ${chalk.green(formatSize(totalSize))}`);
+    if (failed > 0) {
+        warning(`Failed to delete ${failed} file(s)`);
+    }
+}
+/**
+ * Open latest report
+ */
+async function openLatestReport() {
+    const files = await getReportFiles();
+    if (files.length === 0) {
+        warning('No reports found');
+        return;
+    }
+    const latest = files[0];
+    console.log(chalk.dim(`Opening: ${latest.name}`));
+    const { exec } = await import('child_process');
+    const { promisify } = await import('util');
+    const execAsync = promisify(exec);
+    try {
+        await execAsync(`open "${latest.path}"`);
+        success('Report opened in browser');
+    }
+    catch (error) {
+        warning('Failed to open report');
+        console.log(chalk.dim(`Path: ${latest.path}`));
+    }
+}
+/**
+ * Execute reports command
+ */
+async function reportsCommand(subcommand, options) {
+    switch (subcommand) {
+        case 'list':
+            await listReports();
+            break;
+        case 'clean':
+            await cleanReports(options);
+            break;
+        case 'open':
+            await openLatestReport();
+            break;
+        default:
+            await listReports();
+            break;
+    }
+}
+/**
+ * Create reports command
+ */
+export function createReportsCommand() {
+    const cmd = new Command('reports')
+        .description('Manage cleanup reports')
+        .argument('[subcommand]', 'Subcommand: list, clean, open', 'list')
+        .option('-y, --yes', 'Skip confirmation prompts')
+        .action(async (subcommand, options) => {
+        await reportsCommand(subcommand, options);
+    });
+    return enhanceCommandHelp(cmd);
+}