filemayor 3.6.0 → 4.0.7

package/core/analyzer.js

@@ -1,163 +1,163 @@
-#!/usr/bin/env node
-
-/**
- * ═══════════════════════════════════════════════════════════════════
- * FILEMAYOR CORE — ANALYZER
- * Deep filesystem insights: duplicate detection, bloat mapping,
- * and potential savings calculation.
- * ═══════════════════════════════════════════════════════════════════
- */
-
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-const crypto = require('crypto');
-const { scan } = require('./scanner');
-const { findJunk } = require('./cleaner');
-const { formatBytes } = require('./scanner');
-
-/**
- * Analyze a directory for duplicates, bloat, and junk
- * @param {string} dirPath - Root directory to analyze
- * @param {Object} options - Analysis options
- * @returns {Object} Deep analysis results
- */
-function analyzeDirectory(dirPath, options = {}) {
-    const {
-        maxDepth = 10,
-        minSize = 1024, // Ignore files smaller than 1KB for duplicate analysis
-    } = options;
-
-    // 1. Initial Scan
-    const scanResult = scan(dirPath, { maxDepth, includeDirectories: true });
-    const { files, stats } = scanResult;
-
-    // 2. Duplicate Detection (Size-first hashing)
-    const sizeMap = new Map();
-    const duplicates = [];
-
-    // Group by size first (fast)
-    for (const file of files) {
-        if (file.size < minSize) continue;
-        if (!sizeMap.has(file.size)) {
-            sizeMap.set(file.size, []);
-        }
-        sizeMap.get(file.size).push(file);
-    }
-
-    // Hash only those with identical sizes
-    for (const [size, candidateFiles] of sizeMap.entries()) {
-        if (candidateFiles.length < 2) continue;
-
-        const hashMap = new Map();
-        for (const file of candidateFiles) {
-            try {
-                // Partial hash (first 16KB) for efficiency
-                const hash = getFileHash(file.path, 16384);
-                if (!hashMap.has(hash)) {
-                    hashMap.set(hash, []);
-                }
-                hashMap.get(hash).push(file);
-            } catch (err) {
-                // Skip files we can't read
-            }
-        }
-
-        for (const [hash, dupeFiles] of hashMap.entries()) {
-            if (dupeFiles.length > 1) {
-                duplicates.push({
-                    size,
-                    sizeHuman: formatBytes(size),
-                    files: dupeFiles.map(f => ({ name: f.name, path: f.path, relativePath: f.relativePath })),
-                    wastedSpace: size * (dupeFiles.length - 1),
-                    wastedSpaceHuman: formatBytes(size * (dupeFiles.length - 1))
-                });
-            }
-        }
-    }
-    // 3. Bloat Mapping (Top Directories) & Progress Reporting
-    const dirMap = new Map();
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-
-        // Progress callback
-        if (options.onProgress) {
-            options.onProgress({
-                current: i + 1,
-                total: files.length,
-                percent: Math.round(((i + 1) / files.length) * 100),
-                file: file.name
-            });
-        }
-
-        const parts = file.relativePath.split(path.sep);
-        let currentPath = '';
-        // Only track top-level and second-level folders for bloat mapping
-        for (let j = 0; j < Math.min(parts.length - 1, 2); j++) {
-            currentPath = currentPath ? path.join(currentPath, parts[j]) : parts[j];
-            if (!dirMap.has(currentPath)) {
-                dirMap.set(currentPath, { size: 0, count: 0 });
-            }
-            const info = dirMap.get(currentPath);
-            info.size += file.size;
-            info.count += 1;
-        }
-    }
-
-    const largestDirs = Array.from(dirMap.entries())
-        .map(([name, info]) => ({ name, ...info, sizeHuman: formatBytes(info.size) }))
-        .sort((a, b) => b.size - a.size)
-        .slice(0, 5);
-
-    // 4. Junk Detection Integration
-    const junkResult = findJunk(dirPath, { maxDepth });
-    const totalJunkSize = junkResult.stats.totalSize;
-    const totalDuplicateWasted = duplicates.reduce((sum, d) => sum + d.wastedSpace, 0);
-
-    return {
-        root: dirPath,
-        timestamp: Date.now(),
-        summary: {
-            totalFiles: stats.filesFound,
-            totalSize: stats.totalSize,
-            totalSizeHuman: formatBytes(stats.totalSize),
-            potentialSavings: totalJunkSize + totalDuplicateWasted,
-            potentialSavingsHuman: formatBytes(totalJunkSize + totalDuplicateWasted)
-        },
-        duplicates: {
-            sets: duplicates.length,
-            totalWasted: totalDuplicateWasted,
-            totalWastedHuman: formatBytes(totalDuplicateWasted),
-            details: duplicates.sort((a, b) => b.wastedSpace - a.wastedSpace).slice(0, 10)
-        },
-        largestDirs,
-        junk: {
-            count: junkResult.junk.length,
-            totalSize: totalJunkSize,
-            totalSizeHuman: formatBytes(totalJunkSize),
-            categories: junkResult.stats.byCategory
-        }
-    };
-}
-
-/**
- * Get hash of file content (partial or full)
- */
-function getFileHash(filePath, limit = null) {
-    const buffer = limit
-        ? Buffer.alloc(limit)
-        : fs.readFileSync(filePath);
-
-    if (limit) {
-        const fd = fs.openSync(filePath, 'r');
-        fs.readSync(fd, buffer, 0, limit, 0);
-        fs.closeSync(fd);
-    }
-
-    return crypto.createHash('md5').update(buffer).digest('hex');
-}
-
-module.exports = {
-    analyzeDirectory
-};
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — ANALYZER
+ * Deep filesystem insights: duplicate detection, bloat mapping,
+ * and potential savings calculation.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { scan } = require('./scanner');
+const { findJunk } = require('./cleaner');
+const { formatBytes } = require('./scanner');
+
+/**
+ * Analyze a directory for duplicates, bloat, and junk
+ * @param {string} dirPath - Root directory to analyze
+ * @param {Object} options - Analysis options
+ * @returns {Object} Deep analysis results
+ */
+function analyzeDirectory(dirPath, options = {}) {
+    const {
+        maxDepth = 10,
+        minSize = 1024, // Ignore files smaller than 1KB for duplicate analysis
+    } = options;
+
+    // 1. Initial Scan
+    const scanResult = scan(dirPath, { maxDepth, includeDirectories: true });
+    const { files, stats } = scanResult;
+
+    // 2. Duplicate Detection (Size-first hashing)
+    const sizeMap = new Map();
+    const duplicates = [];
+
+    // Group by size first (fast)
+    for (const file of files) {
+        if (file.size < minSize) continue;
+        if (!sizeMap.has(file.size)) {
+            sizeMap.set(file.size, []);
+        }
+        sizeMap.get(file.size).push(file);
+    }
+
+    // Hash only those with identical sizes
+    for (const [size, candidateFiles] of sizeMap.entries()) {
+        if (candidateFiles.length < 2) continue;
+
+        const hashMap = new Map();
+        for (const file of candidateFiles) {
+            try {
+                // Partial hash (first 16KB) for efficiency
+                const hash = getFileHash(file.path, 16384);
+                if (!hashMap.has(hash)) {
+                    hashMap.set(hash, []);
+                }
+                hashMap.get(hash).push(file);
+            } catch (err) {
+                // Skip files we can't read
+            }
+        }
+
+        for (const [hash, dupeFiles] of hashMap.entries()) {
+            if (dupeFiles.length > 1) {
+                duplicates.push({
+                    size,
+                    sizeHuman: formatBytes(size),
+                    files: dupeFiles.map(f => ({ name: f.name, path: f.path, relativePath: f.relativePath })),
+                    wastedSpace: size * (dupeFiles.length - 1),
+                    wastedSpaceHuman: formatBytes(size * (dupeFiles.length - 1))
+                });
+            }
+        }
+    }
+    // 3. Bloat Mapping (Top Directories) & Progress Reporting
+    const dirMap = new Map();
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+
+        // Progress callback
+        if (options.onProgress) {
+            options.onProgress({
+                current: i + 1,
+                total: files.length,
+                percent: Math.round(((i + 1) / files.length) * 100),
+                file: file.name
+            });
+        }
+
+        const parts = file.relativePath.split(path.sep);
+        let currentPath = '';
+        // Only track top-level and second-level folders for bloat mapping
+        for (let j = 0; j < Math.min(parts.length - 1, 2); j++) {
+            currentPath = currentPath ? path.join(currentPath, parts[j]) : parts[j];
+            if (!dirMap.has(currentPath)) {
+                dirMap.set(currentPath, { size: 0, count: 0 });
+            }
+            const info = dirMap.get(currentPath);
+            info.size += file.size;
+            info.count += 1;
+        }
+    }
+
+    const largestDirs = Array.from(dirMap.entries())
+        .map(([name, info]) => ({ name, ...info, sizeHuman: formatBytes(info.size) }))
+        .sort((a, b) => b.size - a.size)
+        .slice(0, 5);
+
+    // 4. Junk Detection Integration
+    const junkResult = findJunk(dirPath, { maxDepth });
+    const totalJunkSize = junkResult.stats.totalSize;
+    const totalDuplicateWasted = duplicates.reduce((sum, d) => sum + d.wastedSpace, 0);
+
+    return {
+        root: dirPath,
+        timestamp: Date.now(),
+        summary: {
+            totalFiles: stats.filesFound,
+            totalSize: stats.totalSize,
+            totalSizeHuman: formatBytes(stats.totalSize),
+            potentialSavings: totalJunkSize + totalDuplicateWasted,
+            potentialSavingsHuman: formatBytes(totalJunkSize + totalDuplicateWasted)
+        },
+        duplicates: {
+            sets: duplicates.length,
+            totalWasted: totalDuplicateWasted,
+            totalWastedHuman: formatBytes(totalDuplicateWasted),
+            details: duplicates.sort((a, b) => b.wastedSpace - a.wastedSpace).slice(0, 10)
+        },
+        largestDirs,
+        junk: {
+            count: junkResult.junk.length,
+            totalSize: totalJunkSize,
+            totalSizeHuman: formatBytes(totalJunkSize),
+            categories: junkResult.stats.byCategory
+        }
+    };
+}
+
+/**
+ * Get hash of file content (partial or full)
+ */
+function getFileHash(filePath, limit = null) {
+    const buffer = limit
+        ? Buffer.alloc(limit)
+        : fs.readFileSync(filePath);
+
+    if (limit) {
+        const fd = fs.openSync(filePath, 'r');
+        fs.readSync(fd, buffer, 0, limit, 0);
+        fs.closeSync(fd);
+    }
+
+    return crypto.createHash('md5').update(buffer).digest('hex');
+}
+
+module.exports = {
+    analyzeDirectory
+};