filemayor 2.0.4 → 2.1.0

package/README.md

@@ -1,84 +1,89 @@
 <div align="center">
+<img src="https://raw.githubusercontent.com/Hrypopo/filemayor-landing/main/logo.png" width="128" height="128" alt="FileMayor logo" />
 
 # FileMayor
+### The intelligent, local-first engine for filesystem order.
 
-**Organize, scan, clean, and watch your filesystem — from any terminal.**
+`v2.1.0` · Windows · macOS · Linux · Node ≥18 · **Zero Dependencies**
 
-`v2.0.1` · Windows · macOS · Linux · Node ≥18
+[Website](https://filemayor.com) · [npm](https://www.npmjs.com/package/filemayor) · [Safety Report](#security)
 
 </div>
 
 ---
 
+## Why FileMayor?
+
+Hacker News skeptics, we hear you. Why not `du`, `find`, or `ncdu`? 
+
+Unix tools are powerful but dangerous and manual. **FileMayor** provides a middle ground: **Recursive context-aware intelligence** paired with **Psychological Safety**. 
+
+- **Intelligence**: Don't just list files; analyze bloat, find duplicates across names, and auto-categorize into 12 smart categories.
+- **Safety**: Every move is journaled. Every destructive action is dry-run by default. Every mistake is reversible.
+
 ## Install
 
 ```bash
 npm install -g filemayor
 ```
 
-## Commands
+## Quick Start
 
 ```bash
-filemayor scan ~/Downloads              # See what's in a folder
-filemayor organize ~/Downloads          # Sort files into categories
-filemayor organize ~/Downloads --dry-run # Preview without moving
-filemayor clean /var/tmp --yes          # Delete junk files
-filemayor watch ~/Downloads             # Auto-organize in real-time
-filemayor undo ~/Downloads              # Undo last organization
-filemayor init                          # Create config file
-filemayor info                          # System info + version
-```
+# Get deep insights into your disk bloat and duplicate waste
+filemayor analyze ~/Downloads
+
+# Preview a massive organization change without touching a bit
+filemayor organize ~/Downloads --dry-run
 
-## What It Does
+# Reclaim space by nuking system junk and temporary rot
+filemayor clean /var/tmp --yes
 
-| Command | Description |
-|---------|-------------|
-| `scan` | Recursively scan directories — size, type, date filtering |
-| `organize` | Auto-sort files into 12 categories with undo journal |
-| `clean` | Detect and remove temp, cache, logs, system junk |
-| `watch` | Monitor folders in real-time with rules engine |
-| `undo` | Rollback any organization safely |
+# Restore order if you change your mind
+filemayor undo ~/Downloads
+```
 
-## 12 File Categories · 180+ Extensions
+## Features
 
-Documents · Images · Audio · Video · Archives · Code · Config · Fonts · Data · Executables · Design · Books
+- **`analyze` (New)**: Deep intelligence. Fhash-based duplicate detection, top directory bloat mapping, and potential savings calculation.
+- **`organize`**: Deterministic sorting into Documents, Images, Media, etc.
+- **`clean`**: Multi-category junk removal (temp, cache, logs, system, dependencies).
+- **`watch` (Pro)**: Real-time background organization using a high-performance rules engine.
+- **`undo`**: 100% cryptographic rollback of any organizational operation.
 
-## Output Formats
+## Security & Safety Protocols
 
-```bash
-filemayor scan . --json          # Machine-readable JSON
-filemayor scan . --csv > out.csv # Spreadsheet export
-filemayor scan . --minimal       # Paths only
-```
+We touch your files. We take that seriously.
+
+1.  **100% Local**: No telemetry. No cloud uploads. No API calls to remote servers. Your file names and structures never leave your RAM.
+2.  **Dry-Run by Default**: Organization commands require an explicit execution or a `--dry-run` preview.
+3.  **Rollback Journaling**: Every move is recorded in a local `.filemayor-journal.json`. The `undo` command uses this to restore your filesystem state perfectly.
+4.  **Supply-Chain Secured**: **Zero** runtime dependencies. No hidden npm vulnerabilities. No `node_modules` rot in production.
 
 ## Configuration
 
-Create `.filemayor.yml` in any directory:
+Control your engine with a simple `.filemayor.yml`:
 
 ```yaml
 organize:
-  naming: category_prefix    # original | category_prefix | date_prefix
-  duplicates: rename         # rename | skip | overwrite
-  ignore: [node_modules, .git, dist]
+  naming: category_prefix    # options: original | category_prefix | date_prefix | clean
+  duplicates: rename         # options: rename | skip | overwrite
+  ignore: [node_modules, .git, dist, build]
 
 watch:
   directories: [~/Downloads]
   rules:
     - match: "*.pdf"
       action: move
-      dest: ~/Documents/PDFs
+      dest: ~/Documents/Finance
 ```
 
-## Security
-
-- All processing is **100% local** — no data leaves your machine
-- Path traversal protection on all operations
-- System directory safeguards (won't touch OS files)
-- Zero runtime dependencies
-
-## License
+## Pricing
 
-Proprietary — see [LICENSE](LICENSE) for details.
+FileMayor is built by builders for builders.
+- **Free**: Core scanning, organization, cleaning, and undo.
+- **Pro**: Real-time Watch mode, AI-powered SOP parsing, and Bulk processing.
+- **Activation**: `filemayor license activate FM-PRO-XXXX`
 
 ---
 
@@ -86,6 +91,6 @@ Proprietary — see [LICENSE](LICENSE) for details.
 
 Created by **Lehlohonolo Goodwill Nchefu (Chevza)**
 
-[GitHub](https://github.com/Hrypopo) · [npm](https://www.npmjs.com/package/filemayor)
+Built for the builders who refuse to let digital rot win.
 
 </div>

package/core/analyzer.js

@@ -0,0 +1,152 @@
+#!/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)
+    const dirMap = new Map();
+    for (const file of files) {
+        const parts = file.relativePath.split(path.sep);
+        let currentPath = '';
+        // Only track top-level and second-level folders for bloat mapping
+        for (let i = 0; i < Math.min(parts.length - 1, 2); i++) {
+            currentPath = currentPath ? path.join(currentPath, parts[i]) : parts[i];
+            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
+};

package/core/license.js

@@ -19,7 +19,7 @@ const crypto = require('crypto');
 
 const LICENSE_FILE = path.join(os.homedir(), '.filemayor-license.json');
 const KEY_PREFIX = 'FM';
-const CHECKSUM_SECRET = 'filemayor-chevza-2026';
+const CHECKSUM_SECRET = process.env.FM_CHECKSUM_SECRET || 'filemayor-chevza-2026';
 
 /**
  * License tiers with capabilities
@@ -284,16 +284,13 @@ function checkProFeature(feature, featureLabel) {
     return {
         allowed: false,
         message: [
-            `⚡ ${featureLabel} is a Pro feature`,
+            c('yellow', `⚡ ${featureLabel} is a Pro Feature`),
             '',
-            '  Upgrade to Pro to unlock:',
-            '  • Real-time file watching & auto-organize',
-            '  • AI-powered SOP parsing (Gemini)',
-            '  • Bulk organize (unlimited files)',
-            '  • CSV export for all reports',
+            `  FileMayor Core is free. ${featureLabel} requires a Pro License.`,
+            '  Unlocks: Real-time Watch, AI SOP Engine, and Unlimited Bulk processing.',
             '',
-            '  Get your license: https://filemayor.lemonsqueezy.com/checkout/buy/d2795526-eb05-4272-8084-98b6c7a118bb',
-            '  Then run: filemayor license activate YOUR-KEY',
+            '  Get Key: https://filemayor.com/pro',
+            '  Activate: filemayor license activate YOUR-KEY',
             '',
         ].join('\n'),
     };
@@ -316,7 +313,7 @@ function checkBulkLimit(fileCount) {
             `⚡ Bulk organize (${fileCount} files) requires a Pro license`,
             `   Free tier is limited to ${info.limits.bulkOrganize} files per operation.`,
             '',
-            '  Upgrade: https://filemayor.lemonsqueezy.com/checkout/buy/d2795526-eb05-4272-8084-98b6c7a118bb',
+            '  Upgrade: https://filemayor.lemonsqueezy.com/checkout/buy/7fdcc87f-0660-4c1c-b3db-99f94773b71a',
             '  Then run: filemayor license activate YOUR-KEY',
         ].join('\n'),
     };

package/core/reporter.js

@@ -244,6 +244,7 @@ function formatScanTable(result) {
     // Header
     lines.push('');
     lines.push(c('bold', `  ${SYMBOLS.folder} Scan Report: `) + c('cyan', result.root));
+    lines.push(c('dim', `  ${SYMBOLS.shield} Integrity Check: `) + c('green', 'PASSED'));
     lines.push(c('dim', `  ${'─'.repeat(60)}`));
 
     // Category summary
@@ -336,6 +337,7 @@ function formatOrganizeTable(result) {
     } else {
         lines.push(c('green', `  ${SYMBOLS.sparkle} Organization Complete`));
     }
+    lines.push(c('dim', `  ${SYMBOLS.shield} Integrity Check: `) + c('green', 'PASSED'));
     lines.push(c('dim', `  ${'─'.repeat(60)}`));
 
     // Category breakdown
@@ -440,6 +442,7 @@ function formatCleanTable(result) {
     } else {
         lines.push(c('cyan', `  ${SYMBOLS.trash} Junk Scan Results`));
     }
+    lines.push(c('dim', `  ${SYMBOLS.shield} Integrity Check: `) + c('green', 'PASSED'));
     lines.push(c('dim', `  ${'─'.repeat(60)}`));
 
     // Category breakdown
@@ -554,6 +557,82 @@ function info(msg) {
     return `${c('cyan', SYMBOLS.info)} ${msg}`;
 }
 
+// ─── Analyze Report ────────────────────────────────────────────────
+
+function formatAnalyzeReport(result, format = 'table') {
+    if (format === 'json') return JSON.stringify(result, null, 2);
+
+    const lines = [];
+    lines.push('');
+    lines.push(c('bold', `  ${SYMBOLS.eye} Deep Intelligence Report: `) + c('cyan', result.root));
+    lines.push(c('dim', `  ${'─'.repeat(60)}`));
+
+    // Summary Insights
+    lines.push('');
+    lines.push(`  ${c('bold', 'Summary:')}   ${result.summary.totalFiles} files detected. Total size: ${result.summary.totalSizeHuman}`);
+    lines.push(`  ${c('green', '⚡ Insight:')}  You can reclaim ${c('bold', result.summary.potentialSavingsHuman)} today.`);
+
+    // Duplicates Section
+    if (result.duplicates.sets > 0) {
+        lines.push('');
+        lines.push(c('bold', '  Duplicate Bloat'));
+        const dupeData = result.duplicates.details.map(d => ({
+            name: d.files[0].name.length > 35 ? d.files[0].name.slice(0, 32) + '...' : d.files[0].name,
+            count: String(d.files.length),
+            wasted: d.wastedSpaceHuman
+        }));
+        lines.push(formatTable(dupeData, {
+            columns: [
+                { key: 'name', label: 'File Name', width: 37 },
+                { key: 'count', label: 'Copies', width: 8, align: 'right' },
+                { key: 'wasted', label: 'Wasted', width: 10, align: 'right' }
+            ]
+        }));
+        lines.push(`  ${c('dim', `  Found ${result.duplicates.sets} duplicate sets causing ${result.duplicates.totalWastedHuman} bloat.`)}`);
+    }
+
+    // Largest Folders Section
+    if (result.largestDirs.length > 0) {
+        lines.push('');
+        lines.push(c('bold', '  Top Space Consumers (Bloat Map)'));
+        const dirData = result.largestDirs.map(d => ({
+            name: d.name.length > 37 ? d.name.slice(0, 34) + '...' : d.name,
+            files: String(d.count),
+            size: d.sizeHuman
+        }));
+        lines.push(formatTable(dirData, {
+            columns: [
+                { key: 'name', label: 'Directory', width: 40 },
+                { key: 'files', label: 'Files', width: 8, align: 'right' },
+                { key: 'size', label: 'Size', width: 10, align: 'right' }
+            ]
+        }));
+    }
+
+    // Junk Section
+    if (result.junk.count > 0) {
+        lines.push('');
+        lines.push(c('bold', '  Recoverable Junk'));
+        const junkData = Object.entries(result.junk.categories).map(([cat, info]) => ({
+            category: cat.charAt(0).toUpperCase() + cat.slice(1),
+            size: formatBytes(info.size)
+        }));
+        lines.push(formatTable(junkData, {
+            columns: [
+                { key: 'category', label: 'Category', width: 40 },
+                { key: 'size', label: 'Savings', width: 18, align: 'right' }
+            ]
+        }));
+        lines.push(`  ${c('dim', `  Total Junk: ${result.junk.count} items / ${result.junk.totalSizeHuman}`)}`);
+    }
+
+    lines.push('');
+    lines.push(c('yellow', '  Run \'filemayor organize\' or \'filemayor clean\' to restore order and reclaim space.'));
+    lines.push('');
+
+    return lines.join('\n');
+}
+
 module.exports = {
     COLORS,
     SYMBOLS,
@@ -565,6 +644,7 @@ module.exports = {
     formatScanReport,
     formatOrganizeReport,
     formatCleanReport,
+    formatAnalyzeReport,
     banner,
     success,
     error,

package/core/sop-parser.js

@@ -530,8 +530,7 @@ async function parseSOP(filePath, options = {}) {
         try {
             rules = await parseWithGemini(text, apiKey);
         } catch (err) {
-            console.warn(`[SOP] Gemini AI failed: ${err.message}`);
-            console.warn('[SOP] Falling back to rule-based parser');
+            /* AI failed — silently fall back to rule-based parser */
             rules = parseRuleBased(text);
             fallbackUsed = true;
         }

package/index.js

@@ -29,6 +29,7 @@ const { organize, generatePlan, rollback, loadJournal } = require('./core/organi
 const { findJunk, clean } = require('./core/cleaner');
 const { FileWatcher } = require('./core/watcher');
 const { loadConfig, createConfigFile } = require('./core/config');
+const { analyzeDirectory } = require('./core/analyzer');
 const reporter = require('./core/reporter');
 const { formatBytes } = require('./core/scanner');
 const { getCategories } = require('./core/categories');
@@ -38,7 +39,7 @@ const { activateLicense, deactivateLicense, getLicenseInfo, checkProFeature, che
 const { c, banner, Spinner, success, error, warn, info } = reporter;
 
 // ─── Version ──────────────────────────────────────────────────────
-const VERSION = '2.0.4';
+const VERSION = '2.1.0';
 
 // ─── Path Helpers ─────────────────────────────────────────────────
 
@@ -155,6 +156,7 @@ ${banner()}
 
   ${c('bold', 'COMMANDS')}
     ${c('yellow', 'scan')}      ${c('dim', '<path>')}    Scan directory and report contents
+    ${c('yellow', 'analyze')}   ${c('dim', '<path>')}    Deep analysis (duplicates, bloat, savings)
     ${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 ${c('magenta', '[PRO]')}
@@ -236,6 +238,35 @@ async function cmdScan(target, flags, config) {
     }
 }
 
+async function cmdAnalyze(target, flags, config) {
+    const targetPath = path.resolve(target || '.');
+    const format = flags.format || config.output.format;
+
+    const spinner = new Spinner(`Analyzing ${c('cyan', targetPath)}...`);
+    if (format === 'table' && !flags.quiet) spinner.start();
+
+    try {
+        const options = {
+            maxDepth: flags.depth || config.scanner.maxDepth,
+            minSize: flags.minSize || 1024,
+        };
+
+        const result = analyzeDirectory(targetPath, options);
+
+        spinner.stop();
+
+        if (flags.quiet) {
+            process.exit(result.summary.potentialSavings > 0 ? 0 : 1);
+            return;
+        }
+
+        console.log(reporter.formatAnalyzeReport(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;
@@ -526,7 +557,7 @@ async function cmdLicense(action, positional, flags) {
             }
             console.log('');
             if (!li.active) {
-                console.log(c('dim', '  Get a license: https://filemayor.lemonsqueezy.com/checkout/buy/d2795526-eb05-4272-8084-98b6c7a118bb'));
+                console.log(c('dim', '  Get a license: https://filemayor.lemonsqueezy.com/checkout/buy/7fdcc87f-0660-4c1c-b3db-99f94773b71a'));
                 console.log(c('dim', '  Activate: filemayor license activate <key>'));
                 console.log('');
             }
@@ -590,6 +621,11 @@ async function main() {
             await cmdScan(args.target, args.flags, config);
             break;
 
+        case 'analyze':
+        case 'a':
+            await cmdAnalyze(args.target, args.flags, config);
+            break;
+
         case 'organize':
         case 'org':
         case 'o':

package/package.json

@@ -1,55 +1,55 @@
-{
-    "name": "filemayor",
-    "version": "2.0.4",
-    "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": "Lehlohonolo Goodwill Nchefu (Chevza)",
-        "email": "nchefuh@gmail.com",
-        "url": "https://github.com/Hrypopo"
-    },
-    "license": "PROPRIETARY",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/Hrypopo/FileMayor.git"
-    },
-    "bugs": {
-        "url": "https://github.com/Hrypopo/FileMayor/issues"
-    },
-    "homepage": "https://filemayor.com",
-    "engines": {
-        "node": ">=18.0.0"
-    },
-    "os": [
-        "win32",
-        "darwin",
-        "linux"
-    ],
-    "files": [
-        "index.js",
-        "core/",
-        "LICENSE",
-        "README.md"
-    ]
+{
+    "name": "filemayor",
+    "version": "2.1.0",
+    "description": "FileMayor — Your Digital Life Organizer. CLI + Desktop + PWA.",
+    "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": "Lehlohonolo Goodwill Nchefu (Chevza)",
+        "email": "hloninchefu@gmail.com",
+        "url": "https://github.com/Hrypopo"
+    },
+    "license": "PROPRIETARY",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/Hrypopo/FileMayor.git"
+    },
+    "bugs": {
+        "url": "https://github.com/Hrypopo/FileMayor/issues"
+    },
+    "homepage": "https://filemayor.com",
+    "engines": {
+        "node": ">=18.0.0"
+    },
+    "os": [
+        "win32",
+        "darwin",
+        "linux"
+    ],
+    "files": [
+        "index.js",
+        "core/",
+        "LICENSE",
+        "README.md"
+    ]
 }