filemayor 2.0.0

package/index.js

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ *
+ *   ███████╗██╗██╗     ███████╗███╗   ███╗ █████╗ ██╗   ██╗ ██████╗ ██████╗
+ *   ██╔════╝██║██║     ██╔════╝████╗ ████║██╔══██╗╚██╗ ██╔╝██╔═══██╗██╔══██╗
+ *   █████╗  ██║██║     █████╗  ██╔████╔██║███████║ ╚████╔╝ ██║   ██║██████╔╝
+ *   ██╔══╝  ██║██║     ██╔══╝  ██║╚██╔╝██║██╔══██║  ╚██╔╝  ██║   ██║██╔══██╗
+ *   ██║     ██║███████╗███████╗██║ ╚═╝ ██║██║  ██║   ██║   ╚██████╔╝██║  ██║
+ *   ╚═╝     ╚═╝╚══════╝╚══════╝╚═╝     ╚═╝╚═╝  ╚═╝   ╚═╝    ╚═════╝ ╚═╝  ╚═╝
+ *
+ *   Your Digital Life Organizer — CLI Edition
+ *   Works everywhere: terminals, servers, data centers, CI/CD
+ *
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const path = require('path');
+const os = require('os');
+const fs = require('fs');
+
+// Core modules
+const { scan, scanByCategory, scanSummary } = require('./core/scanner');
+const { organize, generatePlan, rollback, loadJournal } = require('./core/organizer');
+const { findJunk, clean } = require('./core/cleaner');
+const { FileWatcher } = require('./core/watcher');
+const { loadConfig, createConfigFile } = require('./core/config');
+const reporter = require('./core/reporter');
+const { formatBytes } = require('./core/scanner');
+const { getCategories } = require('./core/categories');
+const { checkPermissions } = require('./core/security');
+
+const { c, banner, Spinner, success, error, warn, info } = reporter;
+
+// ─── Version ──────────────────────────────────────────────────────
+const VERSION = '2.0.0';
+
+// ─── Argument Parser ──────────────────────────────────────────────
+
+function parseArgs(argv) {
+    const args = {
+        command: null,
+        target: null,
+        flags: {},
+        positional: []
+    };
+
+    const raw = argv.slice(2);
+    let i = 0;
+
+    while (i < raw.length) {
+        const arg = raw[i];
+
+        if (arg === '--help' || arg === '-h') {
+            args.flags.help = true;
+        } else if (arg === '--version' || arg === '-V') {
+            args.flags.version = true;
+        } else if (arg === '--dry-run') {
+            args.flags.dryRun = true;
+        } else if (arg === '--json') {
+            args.flags.format = 'json';
+        } else if (arg === '--csv') {
+            args.flags.format = 'csv';
+        } else if (arg === '--minimal') {
+            args.flags.format = 'minimal';
+        } else if (arg === '--yes' || arg === '-y') {
+            args.flags.yes = true;
+        } else if (arg === '--verbose' || arg === '-v') {
+            args.flags.verbose = true;
+        } else if (arg === '--quiet' || arg === '-q') {
+            args.flags.quiet = true;
+        } else if (arg === '--no-color') {
+            args.flags.noColor = true;
+        } else if (arg === '--recursive' || arg === '-r') {
+            args.flags.recursive = true;
+        } else if (arg === '--depth' && raw[i + 1]) {
+            args.flags.depth = parseInt(raw[++i], 10);
+        } else if (arg === '--naming' && raw[i + 1]) {
+            args.flags.naming = raw[++i];
+        } else if (arg === '--output' && raw[i + 1]) {
+            args.flags.outputDir = raw[++i];
+        } else if (arg === '--config' && raw[i + 1]) {
+            args.flags.config = raw[++i];
+        } else if (arg === '--duplicates' && raw[i + 1]) {
+            args.flags.duplicates = raw[++i];
+        } else if (arg === '--extensions' && raw[i + 1]) {
+            args.flags.extensions = raw[++i].split(',');
+        } else if (arg === '--category' && raw[i + 1]) {
+            args.flags.category = raw[++i].split(',');
+        } else if (arg === '--min-size' && raw[i + 1]) {
+            args.flags.minSize = parseSizeArg(raw[++i]);
+        } else if (arg === '--max-size' && raw[i + 1]) {
+            args.flags.maxSize = parseSizeArg(raw[++i]);
+        } else if (arg.startsWith('--')) {
+            // Unknown flag with potential value
+            const key = arg.slice(2).replace(/-([a-z])/g, (_, l) => l.toUpperCase());
+            if (raw[i + 1] && !raw[i + 1].startsWith('-')) {
+                args.flags[key] = raw[++i];
+            } else {
+                args.flags[key] = true;
+            }
+        } else if (arg.startsWith('-') && arg.length === 2) {
+            args.flags[arg.slice(1)] = true;
+        } else if (!args.command) {
+            args.command = arg;
+        } else if (!args.target) {
+            args.target = arg;
+        } else {
+            args.positional.push(arg);
+        }
+
+        i++;
+    }
+
+    return args;
+}
+
+function parseSizeArg(str) {
+    const match = str.match(/^(\d+(?:\.\d+)?)\s*(b|kb|mb|gb|tb)?$/i);
+    if (!match) return 0;
+    const num = parseFloat(match[1]);
+    const unit = (match[2] || 'b').toLowerCase();
+    const multipliers = { b: 1, kb: 1024, mb: 1024 ** 2, gb: 1024 ** 3, tb: 1024 ** 4 };
+    return Math.floor(num * (multipliers[unit] || 1));
+}
+
+// ─── Help Text ────────────────────────────────────────────────────
+
+function printHelp() {
+    console.log(`
+${banner()}
+  ${c('bold', 'USAGE')}
+    ${c('cyan', 'filemayor')} ${c('yellow', '<command>')} ${c('dim', '[path]')} ${c('dim', '[options]')}
+
+  ${c('bold', 'COMMANDS')}
+    ${c('yellow', 'scan')}      ${c('dim', '<path>')}    Scan directory and report contents
+    ${c('yellow', 'organize')}  ${c('dim', '<path>')}    Organize files into categories
+    ${c('yellow', 'clean')}     ${c('dim', '<path>')}    Find and remove junk files
+    ${c('yellow', 'watch')}     ${c('dim', '<path>')}    Watch directory for changes (daemon)
+    ${c('yellow', 'init')}                Create .filemayor.yml config
+    ${c('yellow', 'undo')}      ${c('dim', '<path>')}    Undo last organization
+    ${c('yellow', 'info')}                System info and version
+
+  ${c('bold', 'OPTIONS')}
+    ${c('dim', '--dry-run')}           Preview changes without executing
+    ${c('dim', '--json')}              Output as JSON
+    ${c('dim', '--csv')}               Output as CSV
+    ${c('dim', '--minimal')}           Minimal output (paths only)
+    ${c('dim', '--yes, -y')}           Skip confirmation prompts
+    ${c('dim', '--verbose, -v')}       Detailed logging
+    ${c('dim', '--quiet, -q')}         Suppress output (exit code only)
+    ${c('dim', '--no-color')}          Disable colored output
+    ${c('dim', '--config <path>')}     Custom config file
+    ${c('dim', '--depth <n>')}         Max recursion depth
+    ${c('dim', '--naming <type>')}     Naming: original|category_prefix|date_prefix|clean
+    ${c('dim', '--duplicates <s>')}    Duplicates: rename|skip|overwrite
+    ${c('dim', '--extensions <e>')}    Filter by extensions (comma-separated)
+    ${c('dim', '--output <path>')}     Output directory for organized files
+    ${c('dim', '--category <c>')}      Filter by category (comma-separated)
+    ${c('dim', '--min-size <s>')}      Minimum file size (e.g., 1mb)
+    ${c('dim', '--max-size <s>')}      Maximum file size (e.g., 100mb)
+    ${c('dim', '--help, -h')}          Show this help
+    ${c('dim', '--version, -V')}       Show version
+
+  ${c('bold', 'EXAMPLES')}
+    ${c('dim', '$')} filemayor scan ~/Downloads
+    ${c('dim', '$')} filemayor organize ~/Downloads --dry-run
+    ${c('dim', '$')} filemayor organize ~/Downloads --naming category_prefix
+    ${c('dim', '$')} filemayor clean /var/tmp --yes
+    ${c('dim', '$')} filemayor scan . --json | jq '.files | length'
+    ${c('dim', '$')} filemayor watch ~/Downloads
+    ${c('dim', '$')} filemayor init
+
+  ${c('bold', 'INSTALL')}
+    ${c('dim', '$')} npm install -g filemayor
+
+  ${c('dim', `FileMayor v${VERSION} — https://filemayor.app`)}
+`);
+}
+
+// ─── Commands ─────────────────────────────────────────────────────
+
+async function cmdScan(target, flags, config) {
+    const targetPath = path.resolve(target || '.');
+    const format = flags.format || config.output.format;
+
+    const spinner = new Spinner(`Scanning ${c('cyan', targetPath)}...`);
+    if (format === 'table' && !flags.quiet) spinner.start();
+
+    try {
+        const options = {
+            maxDepth: flags.depth || config.scanner.maxDepth,
+            includeHidden: config.scanner.includeHidden,
+            ignore: config.organize.ignore,
+            extensions: flags.extensions || null,
+            minSize: flags.minSize || config.scanner.minSize,
+            maxSize: flags.maxSize || config.scanner.maxSize || Infinity,
+            followSymlinks: config.scanner.followSymlinks,
+        };
+
+        const result = scan(targetPath, options);
+
+        spinner.stop();
+
+        if (flags.quiet) {
+            process.exit(result.files.length > 0 ? 0 : 1);
+            return;
+        }
+
+        console.log(reporter.formatScanReport(result, format));
+    } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}
+
+async function cmdOrganize(target, flags, config) {
+    const targetPath = path.resolve(target || '.');
+    const format = flags.format || config.output.format;
+    const dryRun = flags.dryRun || false;
+
+    const spinner = new Spinner(`${dryRun ? 'Planning' : 'Organizing'} ${c('cyan', targetPath)}...`);
+    if (format === 'table' && !flags.quiet) spinner.start();
+
+    try {
+        const result = organize(targetPath, {
+            dryRun,
+            naming: flags.naming || config.organize.naming,
+            outputDir: flags.outputDir || null,
+            duplicateStrategy: flags.duplicates || config.organize.duplicates,
+            scanOptions: {
+                maxDepth: flags.depth || config.organize.maxDepth,
+                includeHidden: config.organize.includeHidden,
+                ignore: config.organize.ignore,
+                extensions: flags.extensions || null,
+            },
+            onProgress: format === 'table' ? (p) => {
+                spinner.update(`${dryRun ? 'Planning' : 'Organizing'} ${p.percent}% — ${p.file}`);
+            } : null,
+        });
+
+        spinner.stop();
+
+        if (flags.quiet) {
+            process.exit(0);
+            return;
+        }
+
+        console.log(reporter.formatOrganizeReport(result, format));
+
+        if (!dryRun && result.execSummary) {
+            const exec = result.execSummary;
+            if (exec.failed > 0) process.exit(1);
+        }
+    } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}
+
+async function cmdClean(target, flags, config) {
+    const targetPath = path.resolve(target || '.');
+    const format = flags.format || config.output.format;
+    const dryRun = flags.dryRun || !flags.yes;
+
+    // If --yes not passed and not --dry-run, force dry run
+    if (!flags.yes && !flags.dryRun) {
+        console.log(warn('Running in dry-run mode. Use --yes to actually delete files.'));
+    }
+
+    const spinner = new Spinner(`Scanning for junk in ${c('cyan', targetPath)}...`);
+    if (format === 'table' && !flags.quiet) spinner.start();
+
+    try {
+        const result = clean(targetPath, {
+            dryRun,
+            categories: flags.category || config.clean.categories,
+            maxDepth: flags.depth || config.clean.maxDepth,
+            includeDirectories: config.clean.includeDirectories,
+            onProgress: format === 'table' ? (p) => {
+                spinner.update(`${p.phase === 'scanning' ? 'Scanning' : 'Deleting'} ${p.current || ''}...`);
+            } : null,
+        });
+
+        spinner.stop();
+
+        if (flags.quiet) {
+            process.exit(result.junk.length > 0 ? 0 : 1);
+            return;
+        }
+
+        console.log(reporter.formatCleanReport(result, format));
+    } catch (err) {
+        spinner.fail(err.message);
+        process.exit(1);
+    }
+}
+
+async function cmdWatch(target, flags, config) {
+    const targetPath = path.resolve(target || '.');
+    const format = flags.format || config.output.format;
+
+    console.log(banner());
+    console.log(info(`Watching ${c('cyan', targetPath)} for changes...`));
+    console.log(c('dim', '  Press Ctrl+C to stop\n'));
+
+    const watcher = new FileWatcher({
+        directories: [targetPath, ...(config.watch.directories || [])],
+        rules: config.watch.rules || [],
+        debounceMs: config.watch.debounceMs || 500,
+        recursive: flags.recursive !== false,
+        autoOrganize: config.watch.autoOrganize || false,
+        organizeOptions: {
+            naming: config.organize.naming,
+            duplicateStrategy: config.organize.duplicates,
+        },
+    });
+
+    watcher.on('watching', (data) => {
+        console.log(success(`Watching: ${data.directory}`));
+    });
+
+    watcher.on('change', (event) => {
+        if (format === 'json') {
+            console.log(JSON.stringify(event));
+        } else {
+            const action = event.exists
+                ? c('green', event.type === 'rename' ? 'NEW' : 'CHG')
+                : c('red', 'DEL');
+            const cat = event.category ? c('dim', ` [${event.category}]`) : '';
+            console.log(`  ${action} ${event.filename}${cat} ${c('dim', event.sizeHuman)}`);
+        }
+    });
+
+    watcher.on('action', (data) => {
+        console.log(`  ${c('yellow', '→')} ${data.action}: ${path.basename(data.source)} → ${data.destination || ''}`);
+    });
+
+    watcher.on('error', (err) => {
+        console.error(error(err.error || err.message));
+    });
+
+    watcher.start();
+
+    // Handle shutdown
+    process.on('SIGINT', () => {
+        console.log('\n');
+        watcher.stop();
+        const stats = watcher.getStats();
+        console.log(info(`Processed ${stats.eventsProcessed} events, ${stats.filesActioned} actions`));
+        process.exit(0);
+    });
+}
+
+async function cmdInit(flags) {
+    try {
+        const configPath = createConfigFile(process.cwd());
+        console.log(success(`Created ${c('cyan', configPath)}`));
+        console.log(c('dim', '  Edit this file to customize FileMayor settings'));
+    } catch (err) {
+        console.error(error(err.message));
+        process.exit(1);
+    }
+}
+
+async function cmdUndo(target, flags) {
+    const targetPath = path.resolve(target || '.');
+    const journalPath = path.join(targetPath, '.filemayor-journal.json');
+
+    const journal = loadJournal(journalPath);
+    if (journal.length === 0) {
+        console.log(info('No operations to undo'));
+        return;
+    }
+
+    console.log(info(`Found ${journal.length} operations to undo`));
+
+    const spinner = new Spinner('Undoing operations...');
+    spinner.start();
+
+    const result = rollback(journal, {
+        onProgress: (p) => {
+            spinner.update(`Undoing ${p.percent}% — ${p.file}`);
+        }
+    });
+
+    spinner.stop();
+    console.log(success(`Undone ${result.undone} operations`));
+    if (result.failed > 0) {
+        console.log(warn(`${result.failed} operations could not be undone`));
+        for (const err of result.errors) {
+            console.log(c('dim', `  ${err}`));
+        }
+    }
+
+    // Clear journal
+    try {
+        fs.writeFileSync(journalPath, '[]', 'utf8');
+    } catch { /* ignore */ }
+}
+
+async function cmdInfo(config) {
+    console.log(banner());
+    console.log(`  ${c('bold', 'Version')}    ${VERSION}`);
+    console.log(`  ${c('bold', 'Node')}       ${process.version}`);
+    console.log(`  ${c('bold', 'Platform')}   ${os.platform()} ${os.arch()}`);
+    console.log(`  ${c('bold', 'OS')}         ${os.type()} ${os.release()}`);
+    console.log(`  ${c('bold', 'Home')}       ${os.homedir()}`);
+    console.log(`  ${c('bold', 'CWD')}        ${process.cwd()}`);
+
+    // Config info
+    console.log(`  ${c('bold', 'Config')}     ${config._source || 'defaults'}`);
+
+    // Categories
+    const cats = getCategories();
+    const catCount = Object.keys(cats).length;
+    const extCount = Object.values(cats).reduce((sum, cat) => sum + cat.extensions.length, 0);
+    console.log(`  ${c('bold', 'Categories')} ${catCount} categories, ${extCount} extensions`);
+
+    // Permissions
+    const perms = checkPermissions(process.cwd());
+    const permStr = `${perms.read ? c('green', 'R') : c('red', '-')}${perms.write ? c('green', 'W') : c('red', '-')}${perms.execute ? c('green', 'X') : c('red', '-')}`;
+    console.log(`  ${c('bold', 'Permissions')} ${permStr} (current directory)`);
+
+    console.log('');
+}
+
+// ─── Main Entry Point ─────────────────────────────────────────────
+
+async function main() {
+    const args = parseArgs(process.argv);
+
+    // Version
+    if (args.flags.version) {
+        console.log(VERSION);
+        return;
+    }
+
+    // Colors
+    if (args.flags.noColor || process.env.NO_COLOR) {
+        reporter.setColors(false);
+    }
+
+    // Load config
+    let config;
+    try {
+        const configResult = loadConfig({
+            configPath: args.flags.config || null,
+            cliOverrides: {},
+        });
+        config = configResult.config;
+        config._source = configResult.source;
+
+        // Show validation warnings
+        if (configResult.validation.warnings.length > 0 && args.flags.verbose) {
+            for (const w of configResult.validation.warnings) {
+                console.error(warn(`Config: ${w}`));
+            }
+        }
+        if (!configResult.validation.valid) {
+            for (const e of configResult.validation.errors) {
+                console.error(error(`Config: ${e}`));
+            }
+        }
+    } catch (err) {
+        console.error(error(`Config error: ${err.message}`));
+        process.exit(1);
+    }
+
+    // No command — show help
+    if (!args.command || args.flags.help) {
+        printHelp();
+        return;
+    }
+
+    // Route commands
+    switch (args.command) {
+        case 'scan':
+        case 's':
+            await cmdScan(args.target, args.flags, config);
+            break;
+
+        case 'organize':
+        case 'org':
+        case 'o':
+            await cmdOrganize(args.target, args.flags, config);
+            break;
+
+        case 'clean':
+        case 'cl':
+        case 'c':
+            await cmdClean(args.target, args.flags, config);
+            break;
+
+        case 'watch':
+        case 'w':
+            await cmdWatch(args.target, args.flags, config);
+            break;
+
+        case 'init':
+        case 'i':
+            await cmdInit(args.flags);
+            break;
+
+        case 'undo':
+        case 'u':
+            await cmdUndo(args.target, args.flags);
+            break;
+
+        case 'info':
+            await cmdInfo(config);
+            break;
+
+        case 'help':
+            printHelp();
+            break;
+
+        default:
+            console.error(error(`Unknown command: "${args.command}"`));
+            console.log(c('dim', 'Run "filemayor --help" for usage'));
+            process.exit(1);
+    }
+}
+
+// ─── Run ──────────────────────────────────────────────────────────
+
+main().catch(err => {
+    console.error(error(err.message));
+    if (process.env.DEBUG) {
+        console.error(err.stack);
+    }
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,55 @@
+{
+    "name": "filemayor",
+    "version": "2.0.0",
+    "description": "Enterprise file management engine — scan, organize, clean, and watch your filesystem from any terminal",
+    "main": "index.js",
+    "bin": {
+        "filemayor": "./index.js"
+    },
+    "scripts": {
+        "test": "node --test ../tests/core.test.js"
+    },
+    "keywords": [
+        "file-manager",
+        "file-organizer",
+        "directory-scanner",
+        "cleanup",
+        "filesystem",
+        "cli",
+        "terminal",
+        "productivity",
+        "devtools",
+        "sysadmin",
+        "data-center",
+        "sop",
+        "automation"
+    ],
+    "author": {
+        "name": "FileMayor",
+        "url": "https://github.com/Hrypopo/FileMayor"
+    },
+    "license": "PROPRIETARY",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Hrypopo/FileMayor.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Hrypopo/FileMayor/issues"
+    },
+    "homepage": "https://github.com/Hrypopo/FileMayor#readme",
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "os": [
+        "win32",
+        "darwin",
+        "linux"
+    ],
+    "files": [
+        "index.js",
+        "core/",
+        "package.json",
+        "../LICENSE",
+        "../README.md"
+    ]
+}