filemayor 2.0.0

package/core/cleaner.js

@@ -0,0 +1,527 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — CLEANER
+ * Junk file detection, size calculation, safe deletion with
+ * configurable patterns, category-based cleaning, and reports.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { validatePath, isDirSafe, canRead, canWrite } = require('./security');
+const { formatBytes } = require('./scanner');
+
+// ─── Junk Definitions ─────────────────────────────────────────────
+
+const JUNK_CATEGORIES = {
+    temp: {
+        label: 'Temporary Files',
+        icon: 'Clock',
+        color: '#fb923c',
+        extensions: [
+            '.tmp', '.temp', '.swp', '.swo', '.swn',
+            '.bak', '.backup', '.old', '.orig', '.save',
+            '.crdownload', '.part', '.partial', '.download',
+            '~', '.~lock'
+        ],
+        names: []
+    },
+    cache: {
+        label: 'Cache Files',
+        icon: 'HardDrive',
+        color: '#38bdf8',
+        extensions: [
+            '.cache', '.cached'
+        ],
+        names: [],
+        directories: [
+            '__pycache__', '.cache', '.sass-cache',
+            '.parcel-cache', '.turbo', '.eslintcache',
+            '.stylelintcache', '.prettiercache'
+        ]
+    },
+    system: {
+        label: 'System Junk',
+        icon: 'Shield',
+        color: '#a78bfa',
+        extensions: [],
+        names: [
+            'Thumbs.db', 'ehthumbs.db', 'ehthumbs_vista.db',
+            '.DS_Store', '._.DS_Store', '._*',
+            'desktop.ini', 'Desktop.ini',
+            '.Spotlight-V100', '.Trashes', '.fseventsd',
+            '.TemporaryItems', '.apdisk',
+            'Icon\r', '.directory',
+            '$RECYCLE.BIN', 'RECYCLER',
+            'pagefile.sys', 'swapfile.sys', 'hiberfil.sys'
+        ]
+    },
+    logs: {
+        label: 'Log Files',
+        icon: 'FileText',
+        color: '#fbbf24',
+        extensions: [
+            '.log', '.logs'
+        ],
+        names: [
+            'npm-debug.log', 'yarn-debug.log', 'yarn-error.log',
+            'lerna-debug.log', 'pnpm-debug.log',
+            'debug.log', 'error.log', 'access.log'
+        ],
+        patterns: [
+            'npm-debug.log*', 'yarn-debug.log*', 'yarn-error.log*',
+            '*.log.*', 'crash-*.log'
+        ]
+    },
+    build: {
+        label: 'Build Artifacts',
+        icon: 'Package',
+        color: '#34d399',
+        extensions: [
+            '.o', '.obj', '.pyc', '.pyo', '.class',
+            '.elc', '.beam'
+        ],
+        names: [],
+        directories: [
+            'dist', 'build', 'out', 'output', 'target',
+            '.next', '.nuxt', '.output', '.vercel',
+            'coverage', '.nyc_output', '__snapshots__'
+        ]
+    },
+    dependencies: {
+        label: 'Dependencies',
+        icon: 'Layers',
+        color: '#f472b6',
+        extensions: [],
+        names: [],
+        directories: [
+            'node_modules', '.venv', 'venv', '__pypackages__',
+            'vendor', 'bower_components', '.bundle',
+            'Pods', 'Carthage'
+        ]
+    },
+    ide: {
+        label: 'IDE Artifacts',
+        icon: 'Code',
+        color: '#94a3b8',
+        extensions: [],
+        names: [],
+        directories: [
+            '.idea', '.vscode', '.vs', '.eclipse',
+            '.settings', '.project', '.classpath',
+            '*.sublime-workspace', '.atom'
+        ]
+    }
+};
+
+// ─── Cleaner Class ────────────────────────────────────────────────
+
+class Cleaner {
+    constructor(options = {}) {
+        this.options = {
+            maxDepth: options.maxDepth || 10,
+            categories: options.categories || Object.keys(JUNK_CATEGORIES),
+            includeDirectories: options.includeDirectories !== false,
+            customPatterns: options.customPatterns || {},
+            onProgress: options.onProgress || null,
+            onError: options.onError || null,
+        };
+
+        this.stats = {
+            filesFound: 0,
+            dirsFound: 0,
+            totalSize: 0,
+            dirsScanned: 0,
+            errors: [],
+            startTime: null,
+            endTime: null,
+            byCategory: {}
+        };
+    }
+
+    /**
+     * Scan for junk files in a directory
+     * @param {string} dirPath - Directory to scan
+     * @returns {{ junk: Object[], stats: Object }}
+     */
+    findJunk(dirPath) {
+        const validation = validatePath(dirPath);
+        if (!validation.valid) {
+            throw new Error(`Invalid path: ${validation.error}`);
+        }
+
+        const safeCheck = isDirSafe(validation.resolved);
+        if (!safeCheck.safe) {
+            throw new Error(`Unsafe directory: ${safeCheck.reason}`);
+        }
+
+        if (!canRead(validation.resolved)) {
+            throw new Error(`Permission denied: cannot read "${validation.resolved}"`);
+        }
+
+        this.stats.startTime = Date.now();
+        const junk = [];
+
+        this._scanForJunk(validation.resolved, validation.resolved, 0, junk);
+
+        this.stats.endTime = Date.now();
+        this.stats.duration = this.stats.endTime - this.stats.startTime;
+        this.stats.totalSizeHuman = formatBytes(this.stats.totalSize);
+
+        return {
+            root: validation.resolved,
+            junk,
+            stats: { ...this.stats }
+        };
+    }
+
+    /**
+     * Internal recursive junk scanner
+     */
+    _scanForJunk(dir, rootPath, depth, results) {
+        if (depth > this.options.maxDepth) return;
+
+        this.stats.dirsScanned++;
+
+        if (this.options.onProgress) {
+            this.options.onProgress({
+                phase: 'scanning',
+                currentDir: dir,
+                found: this.stats.filesFound + this.stats.dirsFound,
+                depth
+            });
+        }
+
+        let items;
+        try {
+            items = fs.readdirSync(dir, { withFileTypes: true });
+        } catch (err) {
+            this.stats.errors.push({
+                path: dir,
+                code: err.code,
+                message: err.message
+            });
+            return;
+        }
+
+        for (const item of items) {
+            const fullPath = path.join(dir, item.name);
+
+            if (item.isFile()) {
+                const junkCategory = this._classifyFile(item.name, fullPath);
+                if (junkCategory) {
+                    try {
+                        const stats = fs.statSync(fullPath);
+                        const entry = {
+                            name: item.name,
+                            path: fullPath,
+                            relativePath: path.relative(rootPath, fullPath),
+                            size: stats.size,
+                            sizeHuman: formatBytes(stats.size),
+                            modified: stats.mtime,
+                            category: junkCategory,
+                            categoryLabel: JUNK_CATEGORIES[junkCategory]?.label || junkCategory,
+                            type: 'file'
+                        };
+                        results.push(entry);
+                        this.stats.filesFound++;
+                        this.stats.totalSize += stats.size;
+
+                        // Track by category
+                        if (!this.stats.byCategory[junkCategory]) {
+                            this.stats.byCategory[junkCategory] = { count: 0, size: 0 };
+                        }
+                        this.stats.byCategory[junkCategory].count++;
+                        this.stats.byCategory[junkCategory].size += stats.size;
+                    } catch (err) {
+                        this.stats.errors.push({ path: fullPath, message: err.message });
+                    }
+                }
+            } else if (item.isDirectory()) {
+                // Check if the directory itself is junk
+                const dirJunkCategory = this._classifyDirectory(item.name);
+                if (dirJunkCategory && this.options.includeDirectories) {
+                    try {
+                        const dirSize = this._getDirSize(fullPath);
+                        const entry = {
+                            name: item.name,
+                            path: fullPath,
+                            relativePath: path.relative(rootPath, fullPath),
+                            size: dirSize.size,
+                            sizeHuman: formatBytes(dirSize.size),
+                            fileCount: dirSize.files,
+                            category: dirJunkCategory,
+                            categoryLabel: JUNK_CATEGORIES[dirJunkCategory]?.label || dirJunkCategory,
+                            type: 'directory'
+                        };
+                        results.push(entry);
+                        this.stats.dirsFound++;
+                        this.stats.totalSize += dirSize.size;
+
+                        if (!this.stats.byCategory[dirJunkCategory]) {
+                            this.stats.byCategory[dirJunkCategory] = { count: 0, size: 0 };
+                        }
+                        this.stats.byCategory[dirJunkCategory].count++;
+                        this.stats.byCategory[dirJunkCategory].size += dirSize.size;
+                    } catch (err) {
+                        this.stats.errors.push({ path: fullPath, message: err.message });
+                    }
+                    // Don't recurse into junk directories
+                    continue;
+                }
+
+                // Normal recursion
+                if (!item.name.startsWith('.') || this.options.categories.includes('system')) {
+                    this._scanForJunk(fullPath, rootPath, depth + 1, results);
+                }
+            }
+        }
+
+        // Check for empty directories
+        if (this.options.categories.includes('temp')) {
+            try {
+                const remaining = fs.readdirSync(dir);
+                if (remaining.length === 0 && dir !== rootPath) {
+                    results.push({
+                        name: path.basename(dir),
+                        path: dir,
+                        relativePath: path.relative(rootPath, dir),
+                        size: 0,
+                        sizeHuman: '0 B',
+                        category: 'temp',
+                        categoryLabel: 'Empty Directory',
+                        type: 'empty_directory'
+                    });
+                }
+            } catch { /* ignore */ }
+        }
+    }
+
+    /**
+     * Classify a file as junk (or null if not junk)
+     * @returns {string|null} Category name or null
+     */
+    _classifyFile(filename, fullPath) {
+        const ext = path.extname(filename).toLowerCase();
+
+        for (const catName of this.options.categories) {
+            const cat = JUNK_CATEGORIES[catName];
+            if (!cat) continue;
+
+            // Check extensions
+            if (cat.extensions && cat.extensions.includes(ext)) return catName;
+
+            // Check exact names
+            if (cat.names && cat.names.includes(filename)) return catName;
+
+            // Check patterns
+            if (cat.patterns) {
+                for (const pattern of cat.patterns) {
+                    if (this._matchPattern(pattern, filename)) return catName;
+                }
+            }
+        }
+
+        // Check custom patterns
+        for (const [catName, patterns] of Object.entries(this.options.customPatterns)) {
+            for (const pattern of patterns) {
+                if (this._matchPattern(pattern, filename)) return catName;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Classify a directory as junk
+     * @returns {string|null} Category name or null
+     */
+    _classifyDirectory(dirname) {
+        for (const catName of this.options.categories) {
+            const cat = JUNK_CATEGORIES[catName];
+            if (!cat || !cat.directories) continue;
+            if (cat.directories.includes(dirname)) return catName;
+        }
+        return null;
+    }
+
+    /**
+     * Simple pattern match
+     */
+    _matchPattern(pattern, str) {
+        const regex = pattern
+            .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.');
+        return new RegExp(`^${regex}$`, 'i').test(str);
+    }
+
+    /**
+     * Calculate total size of a directory
+     */
+    _getDirSize(dir, depth = 0) {
+        let size = 0;
+        let files = 0;
+
+        if (depth > 5) return { size, files };
+
+        try {
+            const items = fs.readdirSync(dir, { withFileTypes: true });
+            for (const item of items) {
+                const fullPath = path.join(dir, item.name);
+                if (item.isFile()) {
+                    try {
+                        const stats = fs.statSync(fullPath);
+                        size += stats.size;
+                        files++;
+                    } catch { /* skip */ }
+                } else if (item.isDirectory()) {
+                    const sub = this._getDirSize(fullPath, depth + 1);
+                    size += sub.size;
+                    files += sub.files;
+                }
+            }
+        } catch { /* skip */ }
+
+        return { size, files };
+    }
+}
+
+// ─── Deletion ─────────────────────────────────────────────────────
+
+/**
+ * Delete junk files and directories
+ * @param {Object[]} junkItems - Items from findJunk
+ * @param {Object} options - Deletion options
+ * @returns {{ deleted: number, freed: number, freedHuman: string, errors: Object[] }}
+ */
+function deleteJunk(junkItems, options = {}) {
+    const {
+        onProgress = null,
+        onError = null,
+        filterCategories = null, // Only delete these categories
+    } = options;
+
+    let deleted = 0;
+    let freed = 0;
+    const errors = [];
+
+    // Filter by category if specified
+    const toDelete = filterCategories
+        ? junkItems.filter(item => filterCategories.includes(item.category))
+        : junkItems;
+
+    // Delete files first, then directories (bottom-up)
+    const files = toDelete.filter(i => i.type === 'file');
+    const dirs = toDelete.filter(i => i.type === 'directory' || i.type === 'empty_directory');
+
+    // Delete files
+    for (let i = 0; i < files.length; i++) {
+        const item = files[i];
+
+        if (onProgress) {
+            onProgress({
+                current: i + 1,
+                total: toDelete.length,
+                percent: Math.round(((i + 1) / toDelete.length) * 100),
+                file: item.name,
+                phase: 'deleting'
+            });
+        }
+
+        try {
+            if (!canWrite(path.dirname(item.path))) {
+                throw new Error('Permission denied');
+            }
+            fs.unlinkSync(item.path);
+            deleted++;
+            freed += item.size;
+        } catch (err) {
+            const errorInfo = { path: item.path, message: err.message };
+            errors.push(errorInfo);
+            if (onError) onError(errorInfo);
+        }
+    }
+
+    // Delete directories (sort by depth descending — deepest first)
+    const sortedDirs = dirs.sort((a, b) => {
+        const depthA = a.path.split(path.sep).length;
+        const depthB = b.path.split(path.sep).length;
+        return depthB - depthA;
+    });
+
+    for (const dir of sortedDirs) {
+        try {
+            if (dir.type === 'empty_directory') {
+                fs.rmdirSync(dir.path);
+            } else {
+                fs.rmSync(dir.path, { recursive: true, force: true });
+            }
+            deleted++;
+            freed += dir.size;
+        } catch (err) {
+            errors.push({ path: dir.path, message: err.message });
+        }
+    }
+
+    return {
+        deleted,
+        freed,
+        freedHuman: formatBytes(freed),
+        errors,
+        total: toDelete.length
+    };
+}
+
+// ─── Convenience Functions ────────────────────────────────────────
+
+/**
+ * Quick scan for junk files
+ */
+function findJunk(dirPath, options = {}) {
+    const cleaner = new Cleaner(options);
+    return cleaner.findJunk(dirPath);
+}
+
+/**
+ * Quick clean: scan + delete in one call
+ */
+function clean(dirPath, options = {}) {
+    const { dryRun = false, filterCategories = null, ...scanOptions } = options;
+
+    const result = findJunk(dirPath, scanOptions);
+
+    if (dryRun) {
+        return {
+            dryRun: true,
+            junk: result.junk,
+            stats: result.stats,
+            deleteResult: null
+        };
+    }
+
+    const deleteResult = deleteJunk(result.junk, {
+        filterCategories,
+        onProgress: scanOptions.onProgress,
+        onError: scanOptions.onError,
+    });
+
+    return {
+        dryRun: false,
+        junk: result.junk,
+        stats: result.stats,
+        deleteResult
+    };
+}
+
+module.exports = {
+    JUNK_CATEGORIES,
+    Cleaner,
+    findJunk,
+    deleteJunk,
+    clean
+};