@tukuyomil032/broom 1.0.0

package/dist/ui/output.js

@@ -0,0 +1,304 @@
+/**
+ * Terminal output helpers for Broom CLI
+ */
+import chalk from 'chalk';
+import ora from 'ora';
+import { formatSize } from '../utils/fs.js';
+// Icons
+export const ICONS = {
+    success: '✓',
+    error: '✗',
+    warning: '⚠',
+    info: 'ℹ',
+    arrow: '→',
+    folder: '📁',
+    file: '📄',
+    trash: '🗑',
+    clean: '🧹',
+    disk: '💾',
+    cpu: '🖥',
+    memory: '🧠',
+    network: '🌐',
+    dryRun: '👁',
+    admin: '🔐',
+};
+/**
+ * Print success message
+ */
+export function success(message) {
+    console.log(chalk.green(ICONS.success), message);
+}
+/**
+ * Print error message
+ */
+export function error(message) {
+    console.log(chalk.red(ICONS.error), message);
+}
+/**
+ * Print warning message
+ */
+export function warning(message) {
+    console.log(chalk.yellow(ICONS.warning), message);
+}
+/**
+ * Print info message
+ */
+export function info(message) {
+    console.log(chalk.blue(ICONS.info), message);
+}
+/**
+ * Print separator line
+ */
+export function separator(char = '─', length = 60) {
+    console.log(chalk.gray(char.repeat(length)));
+}
+/**
+ * Print header
+ */
+export function printHeader(title) {
+    console.log();
+    console.log(chalk.bold.magenta(title));
+    separator();
+}
+/**
+ * Print welcome message
+ */
+export function printWelcome() {
+    console.log();
+    console.log(chalk.bold.cyan('🧹 Broom'));
+    console.log(chalk.dim('macOS Disk Cleanup Tool'));
+    separator();
+}
+/**
+ * Print file with details
+ */
+export function printFile(item, index) {
+    const prefix = index !== undefined ? `${String(index + 1).padStart(2, ' ')}.` : '  ';
+    const icon = item.isDirectory ? ICONS.folder : ICONS.file;
+    const size = chalk.yellow(formatSize(item.size).padStart(10));
+    const path = chalk.dim(item.path);
+    console.log(`${prefix} ${icon} ${size}  ${path}`);
+}
+/**
+ * Print file list
+ */
+export function printFiles(items) {
+    items.forEach((item, index) => printFile(item, index));
+}
+/**
+ * Print scan result
+ */
+export function printScanResult(result) {
+    const { category, items, totalSize } = result;
+    const sizeStr = formatSize(totalSize);
+    const countStr = `${items.length} items`;
+    if (items.length > 0) {
+        console.log(`  ${chalk.green(ICONS.success)} ${category.name.padEnd(35)} ${chalk.yellow(sizeStr.padStart(12))} ${chalk.dim(`(${countStr})`)}`);
+    }
+    else {
+        console.log(`  ${chalk.gray(ICONS.info)} ${category.name.padEnd(35)} ${chalk.gray('Empty')}`);
+    }
+}
+/**
+ * Print removal summary
+ */
+export function printRemovalSummary(summary) {
+    separator();
+    console.log(chalk.bold('Removal Summary:'));
+    console.log(`Total files: ${chalk.cyan(summary.totalFiles)}`);
+    console.log(`Successfully removed: ${chalk.green(summary.successCount)}`);
+    if (summary.failureCount > 0) {
+        console.log(`Failed: ${chalk.red(summary.failureCount)}`);
+    }
+    console.log(`Space freed: ${chalk.yellow(formatSize(summary.totalSizeFreed))}`);
+    separator();
+    if (summary.failureCount > 0) {
+        console.log(chalk.bold('\nFailed removals:'));
+        summary.results
+            .filter((r) => !r.success)
+            .forEach((r) => {
+            error(`${r.path}: ${r.error || 'Unknown error'}`);
+        });
+    }
+}
+/**
+ * Print summary block
+ */
+export function printSummaryBlock(heading, details) {
+    console.log();
+    separator('═');
+    console.log(chalk.bold(heading));
+    separator('─');
+    details.forEach((detail) => console.log(`  ${detail}`));
+    separator('═');
+}
+/**
+ * Create spinner
+ */
+export function createSpinner(text) {
+    return ora({
+        text,
+        spinner: 'dots',
+    }).start();
+}
+/**
+ * Start spinner
+ */
+export function startSpinner(text) {
+    return ora(text).start();
+}
+/**
+ * Succeed spinner
+ */
+export function succeedSpinner(spinner, text) {
+    if (text) {
+        spinner.succeed(text);
+    }
+    else {
+        spinner.succeed();
+    }
+}
+/**
+ * Fail spinner
+ */
+export function failSpinner(spinner, text) {
+    if (text) {
+        spinner.fail(text);
+    }
+    else {
+        spinner.fail();
+    }
+}
+/**
+ * Update spinner text
+ */
+export function updateSpinner(spinner, text) {
+    spinner.text = text;
+}
+/**
+ * Print progress bar inline with improved design
+ */
+export function printProgressBar(percent, width = 30, label = '') {
+    const filled = Math.round((percent / 100) * width);
+    // Build bar without gridlines for progress bars
+    let bar = '';
+    for (let i = 0; i < width; i++) {
+        if (i < filled) {
+            const ratio = i / width;
+            if (ratio < 0.5) {
+                bar += chalk.green('█');
+            }
+            else if (ratio < 0.75) {
+                bar += chalk.yellow('█');
+            }
+            else {
+                bar += chalk.red('█');
+            }
+        }
+        else {
+            bar += chalk.gray('░');
+        }
+    }
+    const percentStr = `${percent.toFixed(0)}%`.padStart(4);
+    const line = `\r${chalk.gray('│')}${bar}${chalk.gray('│')} ${percentStr}${label ? ` ${chalk.dim(label)}` : ''}`;
+    process.stdout.write(line);
+}
+/**
+ * Print styled progress bar with message
+ */
+export function printStyledProgressBar(percent, width = 35, message = '', showPercent = true) {
+    const filled = Math.round((percent / 100) * width);
+    // Build bar without gridlines for styled progress bars
+    let bar = chalk.gray('╔');
+    for (let i = 0; i < width; i++) {
+        if (i < filled) {
+            const ratio = i / width;
+            if (ratio < 0.5) {
+                bar += chalk.green('█');
+            }
+            else if (ratio < 0.75) {
+                bar += chalk.yellow('█');
+            }
+            else {
+                bar += chalk.red('█');
+            }
+        }
+        else {
+            bar += chalk.gray('░');
+        }
+    }
+    bar += chalk.gray('╗');
+    const percentStr = showPercent ? ` ${percent.toFixed(0).padStart(3)}%` : '';
+    return `${bar}${percentStr}${message ? ` ${chalk.dim(message)}` : ''}`;
+}
+/**
+ * Create progress tracker
+ */
+export function createProgress(total, taskMessage = 'Processing...') {
+    const spinner = ora(taskMessage).start();
+    return {
+        update: (current, message) => {
+            const percent = Math.round((current / total) * 100);
+            const progressBar = createProgressBar(percent);
+            spinner.text = `${progressBar} ${percent}%${message ? ` - ${message}` : ''}`;
+        },
+        finish: (message) => {
+            spinner.succeed(message || 'Complete');
+        },
+    };
+}
+/**
+ * Create ASCII progress bar
+ */
+function createProgressBar(percent, width = 20) {
+    const filled = Math.round((percent / 100) * width);
+    let bar = '';
+    for (let i = 0; i < width; i++) {
+        const isGridline = i > 0 && i % (width / 5) === 0;
+        if (i < filled) {
+            bar += isGridline ? '│' : '█';
+        }
+        else {
+            bar += isGridline ? '┊' : ' ';
+        }
+    }
+    return `[${bar}]`;
+}
+/**
+ * Clear terminal
+ */
+export function clearTerminal() {
+    if (process.stdout.isTTY) {
+        process.stdout.write('\x1B[2J\x1B[H');
+    }
+}
+/**
+ * Print table
+ */
+export function printTable(headers, rows, columnWidths) {
+    const widths = columnWidths ||
+        headers.map((h, i) => {
+            const maxRow = Math.max(...rows.map((r) => (r[i] || '').length));
+            return Math.max(h.length, maxRow);
+        });
+    // Header
+    const headerRow = headers.map((h, i) => h.padEnd(widths[i])).join(' │ ');
+    console.log(chalk.bold(headerRow));
+    // Separator
+    const sep = widths.map((w) => '─'.repeat(w)).join('─┼─');
+    console.log(chalk.gray(sep));
+    // Rows
+    rows.forEach((row) => {
+        const line = row.map((cell, i) => cell.padEnd(widths[i])).join(' │ ');
+        console.log(line);
+    });
+}
+/**
+ * Show hide cursor
+ */
+export function hideCursor() {
+    process.stdout.write('\x1B[?25l');
+}
+export function showCursor() {
+    process.stdout.write('\x1B[?25h');
+}

package/dist/ui/prompts.js

@@ -0,0 +1,270 @@
+/**
+ * Interactive prompts for Broom CLI
+ */
+import { select, confirm, checkbox, input } from '@inquirer/prompts';
+import chalk from 'chalk';
+import { formatSize } from '../utils/fs.js';
+// Re-export inquirer functions for direct use
+export { select, confirm, checkbox, input };
+/**
+ * Select a category to clean
+ */
+export async function selectCategory(results) {
+    const choices = results
+        .filter((r) => r.items.length > 0)
+        .map((r) => ({
+        name: `${r.category.name} (${formatSize(r.totalSize)} - ${r.items.length} items)`,
+        value: r,
+    }));
+    if (choices.length === 0) {
+        return null;
+    }
+    try {
+        return await select({
+            message: 'Select a category to clean:',
+            choices,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Select multiple categories to clean
+ */
+export async function selectCategories(results) {
+    const choices = results
+        .filter((r) => r.items.length > 0)
+        .map((r) => ({
+        name: `${r.category.name} (${formatSize(r.totalSize)} - ${r.items.length} items)`,
+        value: r,
+        checked: r.category.safetyLevel === 'safe',
+    }));
+    if (choices.length === 0) {
+        return [];
+    }
+    try {
+        return await checkbox({
+            message: 'Select categories to clean (space to toggle):',
+            choices,
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Select files to clean
+ */
+export async function selectFiles(items) {
+    if (items.length === 0) {
+        return [];
+    }
+    const choices = items.map((item) => ({
+        name: `${item.isDirectory ? '📁' : '📄'} ${item.name} (${formatSize(item.size)}) - ${chalk.dim(item.path)}`,
+        value: item,
+        checked: true,
+    }));
+    try {
+        return await checkbox({
+            message: 'Select files to remove:',
+            choices,
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Select an application
+ */
+export async function selectApp(apps) {
+    if (apps.length === 0) {
+        return null;
+    }
+    const choices = apps.map((app) => ({
+        name: `${app.name} (${formatSize(app.size)})${app.bundleId ? chalk.dim(` - ${app.bundleId}`) : ''}`,
+        value: app,
+    }));
+    try {
+        return await select({
+            message: 'Select an application:',
+            choices,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Confirm action
+ */
+export async function confirmAction(message, defaultValue = false) {
+    try {
+        return await confirm({
+            message,
+            default: defaultValue,
+        });
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Confirm removal
+ */
+export async function confirmRemoval(itemCount, totalSize) {
+    try {
+        return await confirm({
+            message: `Remove ${itemCount} item(s) (${formatSize(totalSize)})?`,
+            default: false,
+        });
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Prompt for text input
+ */
+export async function promptInput(message, defaultValue) {
+    try {
+        return await input({
+            message,
+            default: defaultValue,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Text input prompt (alias for promptInput)
+ */
+export async function inputPrompt(message, defaultValue) {
+    return promptInput(message, defaultValue);
+}
+/**
+ * Select from generic items
+ */
+export async function selectItems(message, choices) {
+    if (choices.length === 0) {
+        return [];
+    }
+    try {
+        return await checkbox({
+            message,
+            choices: choices.map((c) => ({
+                name: c.description ? `${c.name} - ${chalk.dim(c.description)}` : c.name,
+                value: c.value,
+            })),
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Select a path (directory browser)
+ */
+export async function selectPath(message, choices) {
+    if (choices.length === 0) {
+        return null;
+    }
+    try {
+        return await select({
+            message,
+            choices,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Select main menu action
+ */
+export async function selectMainAction() {
+    try {
+        return await select({
+            message: 'What would you like to do?',
+            choices: [
+                { name: '🧹 Clean - Deep system cleanup', value: 'clean' },
+                { name: '🗑️  Uninstall - Remove apps completely', value: 'uninstall' },
+                { name: '🔧 Optimize - Check and maintain system', value: 'optimize' },
+                { name: '📊 Analyze - Explore disk usage', value: 'analyze' },
+                { name: '📈 Status - Monitor system health', value: 'status' },
+                { name: '📦 Purge - Clean project artifacts', value: 'purge' },
+                { name: '💿 Installer - Remove installer files', value: 'installer' },
+                { name: '⚙️  Config - Manage settings', value: 'config' },
+                { name: '❌ Exit', value: 'exit' },
+            ],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Select config option
+ */
+export async function selectConfigOption() {
+    try {
+        return await select({
+            message: 'Select a configuration option:',
+            choices: [
+                { name: 'Toggle scan locations', value: 'locations' },
+                { name: 'Manage whitelist', value: 'whitelist' },
+                { name: 'Toggle dry run mode', value: 'dryrun' },
+                { name: 'Reset to defaults', value: 'reset' },
+                { name: 'Exit', value: 'exit' },
+            ],
+        });
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Select scan locations to toggle
+ */
+export async function selectScanLocations(currentLocations) {
+    const choices = [
+        { name: 'User Cache', value: 'userCache', checked: currentLocations.userCache },
+        { name: 'System Cache', value: 'systemCache', checked: currentLocations.systemCache },
+        { name: 'System Logs', value: 'systemLogs', checked: currentLocations.systemLogs },
+        { name: 'User Logs', value: 'userLogs', checked: currentLocations.userLogs },
+        { name: 'Trash', value: 'trash', checked: currentLocations.trash },
+        { name: 'Downloads', value: 'downloads', checked: currentLocations.downloads },
+        { name: 'Browser Cache', value: 'browserCache', checked: currentLocations.browserCache },
+        { name: 'Development Cache', value: 'devCache', checked: currentLocations.devCache },
+        { name: 'Xcode Cache', value: 'xcodeCache', checked: currentLocations.xcodeCache },
+    ];
+    try {
+        return await checkbox({
+            message: 'Select locations to scan:',
+            choices,
+        });
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Select cleanup action
+ */
+export async function selectCleanupAction() {
+    try {
+        return await select({
+            message: 'What would you like to do?',
+            choices: [
+                { name: 'Remove selected files', value: 'remove' },
+                { name: 'Back to category selection', value: 'back' },
+                { name: 'Cancel', value: 'cancel' },
+            ],
+        });
+    }
+    catch {
+        return 'cancel';
+    }
+}

package/dist/utils/config.js

@@ -0,0 +1,133 @@
+/**
+ * Configuration management for Broom CLI
+ */
+import { readFile, writeFile, mkdir } from 'fs/promises';
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync } from 'fs';
+import { DEFAULT_CONFIG } from '../types/index.js';
+const CONFIG_DIR = join(homedir(), '.config', 'broom');
+const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+const WHITELIST_FILE = join(CONFIG_DIR, 'whitelist');
+let configCache = null;
+/**
+ * Ensure config directory exists
+ */
+async function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        await mkdir(CONFIG_DIR, { recursive: true });
+    }
+}
+/**
+ * Load configuration
+ */
+export async function loadConfig() {
+    if (configCache) {
+        return configCache;
+    }
+    try {
+        await ensureConfigDir();
+        if (!existsSync(CONFIG_FILE)) {
+            await saveConfig(DEFAULT_CONFIG);
+            configCache = DEFAULT_CONFIG;
+            return DEFAULT_CONFIG;
+        }
+        const content = await readFile(CONFIG_FILE, 'utf-8');
+        const config = { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+        // Load whitelist
+        if (existsSync(WHITELIST_FILE)) {
+            const whitelistContent = await readFile(WHITELIST_FILE, 'utf-8');
+            config.whitelist = whitelistContent
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line && !line.startsWith('#'));
+        }
+        configCache = config;
+        return config;
+    }
+    catch (error) {
+        configCache = DEFAULT_CONFIG;
+        return DEFAULT_CONFIG;
+    }
+}
+/**
+ * Save configuration
+ */
+export async function saveConfig(config) {
+    await ensureConfigDir();
+    const { whitelist, ...configWithoutWhitelist } = config;
+    await writeFile(CONFIG_FILE, JSON.stringify(configWithoutWhitelist, null, 2), 'utf-8');
+    // Save whitelist separately
+    if (whitelist && whitelist.length > 0) {
+        const whitelistContent = `# Broom Whitelist\n# One path per line\n\n${whitelist.join('\n')}`;
+        await writeFile(WHITELIST_FILE, whitelistContent, 'utf-8');
+    }
+    else {
+        // Delete whitelist file if empty
+        if (existsSync(WHITELIST_FILE)) {
+            const { unlink } = await import('fs/promises');
+            await unlink(WHITELIST_FILE);
+        }
+    }
+    configCache = config;
+}
+/**
+ * Reset configuration to defaults
+ */
+export async function resetConfig() {
+    await saveConfig(DEFAULT_CONFIG);
+    configCache = DEFAULT_CONFIG;
+}
+/**
+ * Get config file path
+ */
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+/**
+ * Get whitelist file path
+ */
+export function getWhitelistPath() {
+    return WHITELIST_FILE;
+}
+/**
+ * Check if path is whitelisted
+ */
+export function isWhitelisted(path, whitelist) {
+    const normalizedPath = path.replace(/\/+$/, '');
+    for (const pattern of whitelist) {
+        const normalizedPattern = pattern.replace(/\/+$/, '').replace('~', homedir());
+        if (normalizedPath === normalizedPattern) {
+            return true;
+        }
+        if (normalizedPath.startsWith(normalizedPattern + '/')) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Add path to whitelist
+ */
+export async function addToWhitelist(path) {
+    const config = await loadConfig();
+    if (!config.whitelist.includes(path)) {
+        config.whitelist.push(path);
+        await saveConfig(config);
+    }
+}
+/**
+ * Remove path from whitelist
+ */
+export async function removeFromWhitelist(path) {
+    const config = await loadConfig();
+    config.whitelist = config.whitelist.filter((p) => p !== path);
+    await saveConfig(config);
+}
+/**
+ * Clear config cache
+ */
+export function clearConfigCache() {
+    configCache = null;
+}
+export { CONFIG_DIR, CONFIG_FILE, WHITELIST_FILE };