filemayor 2.1.0 → 4.0.5

package/core/fs-abstraction.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR FS v3.0 — INTENT-READY FILESYSTEM ABSTRACTION
+ * Async, safe, transactional, and fully rollbackable.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const fs = require('fs').promises;
+const fssync = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const { validatePath, isFileSafe, isDirSafe, canRead, canWrite } = require('./security');
+const { formatBytes } = require('./scanner');
+
+class FileMayorFS {
+    constructor(options = {}) {
+        this.options = {
+            useJournal: true,
+            dryRun: false,
+            trashPath: path.join(os.tmpdir(), 'filemayor_trash'),
+            journalPath: path.join(os.homedir(), '.filemayor-master-journal.ndjson'),
+            ...options
+        };
+        this.sessionJournal = [];
+        this.stats = {
+            opsSucceeded: 0,
+            opsFailed: 0,
+            totalBytesProcessed: 0,
+            filesMoved: 0,
+            filesDeleted: 0
+        };
+        fssync.mkdirSync(this.options.trashPath, { recursive: true });
+    }
+
+    /** ------------------------
+     * Enhanced Snapshot
+     * -------------------------*/
+    async createSnapshot(filePath) {
+        try {
+            const stats = await fs.stat(filePath);
+            return {
+                path: filePath,
+                size: stats.size,
+                mtime: stats.mtimeMs,
+                hash: crypto.createHash('sha256').update(filePath + stats.mtimeMs).digest('hex')
+            };
+        } catch {
+            return { path: filePath };
+        }
+    }
+
+    /** ------------------------
+     * Async Move
+     * -------------------------*/
+    async move(source, destination) {
+        const result = { source, destination, action: 'move', status: 'pending' };
+
+        const sourceCheck = isFileSafe(source);
+        if (!sourceCheck.safe) throw new Error(`Source unsafe: ${sourceCheck.reason}`);
+
+        const destValidation = validatePath(destination);
+        if (!destValidation.valid) throw new Error(`Destination invalid: ${destValidation.error}`);
+
+        const snapshot = await this.createSnapshot(source);
+
+        if (this.options.dryRun) {
+            result.status = 'dry-run';
+            return result;
+        }
+
+        try {
+            const destDir = path.dirname(destination);
+            await fs.mkdir(destDir, { recursive: true });
+
+            // WAL: write pending entry BEFORE the operation
+            const opId = crypto.randomUUID();
+            await this._journalPending(opId, source, destination, 'move', snapshot);
+
+            try {
+                await fs.rename(source, destination);
+            } catch (err) {
+                if (err.code === 'EXDEV') {
+                    await fs.copyFile(source, destination);
+                    await fs.unlink(source);
+                } else throw err;
+            }
+
+            // WAL: record completion AFTER the operation
+            await this._journalDone(opId);
+
+            result.status = 'success';
+            this.stats.opsSucceeded++;
+            this.stats.filesMoved++;
+            this.stats.totalBytesProcessed += snapshot.size || 0;
+
+        } catch (err) {
+            result.status = 'error';
+            result.error = err.message;
+            this.stats.opsFailed++;
+            throw err;
+        }
+
+        return result;
+    }
+
+    /** ------------------------
+     * Safe Delete with Trash
+     * -------------------------*/
+    async delete(target) {
+        const check = isFileSafe(target);
+        if (!check.safe) throw new Error(`Target unsafe: ${check.reason}`);
+
+        const snapshot = await this.createSnapshot(target);
+
+        if (this.options.dryRun) return { target, status: 'dry-run' };
+
+        const trashFile = path.join(this.options.trashPath, path.basename(target) + '-' + Date.now());
+        await fs.rename(target, trashFile);
+
+        this.stats.opsSucceeded++;
+        this.stats.filesDeleted++;
+        this.stats.totalBytesProcessed += snapshot.size || 0;
+
+        await this._logToJournal(target, trashFile, 'delete', snapshot);
+
+        return { target, status: 'success' };
+    }
+
+    /** ------------------------
+     * Journaling (WAL)
+     * -------------------------*/
+    async _journalWriteLine(entry) {
+        if (!this.options.useJournal) return;
+        try {
+            const line = JSON.stringify(entry) + '\n';
+            fssync.appendFileSync(this.options.journalPath, line, 'utf8');
+        } catch (err) {
+            console.error(`[FAIL] Journal write failed: ${err.message}`);
+        }
+    }
+
+    async _logToJournal(source, destination, action, snapshot) {
+        // WAL: record intent BEFORE operation (called pre-move),
+        // then update to 'done' AFTER (called post-move).
+        // This is handled by _journalPending / _journalDone.
+    }
+
+    async _journalPending(id, source, destination, action, snapshot) {
+        const entry = {
+            id,
+            timestamp: new Date().toISOString(),
+            action,
+            source,
+            destination,
+            snapshot,
+            status: 'pending',
+        };
+        this.sessionJournal.push(entry);
+        await this._journalWriteLine(entry);
+        return entry;
+    }
+
+    async _journalDone(id) {
+        await this._journalWriteLine({ id, status: 'done', completedAt: new Date().toISOString() });
+    }
+
+    /** ------------------------
+     * Rollback
+     * -------------------------*/
+    async rollback() {
+        const entries = new Map();
+        const done = new Set();
+
+        if (fssync.existsSync(this.options.journalPath)) {
+            const lines = fssync.readFileSync(this.options.journalPath, 'utf8').split('\n');
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                try {
+                    const rec = JSON.parse(line);
+                    if (rec.status === 'pending') entries.set(rec.id, rec);
+                    if (rec.status === 'done')    done.add(rec.id);
+                } catch { /* skip malformed lines */ }
+            }
+        }
+
+        // Add session-only pending entries not yet on disk
+        for (const e of this.sessionJournal) {
+            if (!entries.has(e.id)) entries.set(e.id, e);
+        }
+
+        // Reverse-order rollback of moves that never completed
+        const toRollback = [...entries.values()]
+            .filter(e => !done.has(e.id))
+            .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+
+        console.log(`[SYS] Rolling back ${toRollback.length} incomplete operations...`);
+
+        for (const entry of toRollback) {
+            try {
+                if (fssync.existsSync(entry.destination)) {
+                    await fs.rename(entry.destination, entry.source);
+                    await this._journalWriteLine({ id: entry.id, status: 'rolled-back', rolledBackAt: new Date().toISOString() });
+                }
+            } catch (err) {
+                console.error(`[FAIL] Rollback failed for ${entry.source}: ${err.message}`);
+            }
+        }
+
+        this.sessionJournal = [];
+        console.log('[SYS] Rollback complete.');
+    }
+
+    getJournal() {
+        return this.sessionJournal;
+    }
+}
+
+const JOURNAL_PATH = path.join(os.homedir(), '.filemayor-master-journal.ndjson');
+
+/**
+ * Standalone rollback function that reads the master journal on disk
+ * and reverses all completed operations (status === 'done').
+ * Returns { reversed: Array<entry>, count: number }.
+ */
+async function rollback(journalPath) {
+    const entries = new Map();
+    const done = new Set();
+
+    if (fssync.existsSync(journalPath)) {
+        const lines = fssync.readFileSync(journalPath, 'utf8').split('\n');
+        for (const line of lines) {
+            if (!line.trim()) continue;
+            try {
+                const rec = JSON.parse(line);
+                if (rec.status === 'pending') entries.set(rec.id, rec);
+                if (rec.status === 'done')    done.add(rec.id);
+            } catch { /* skip malformed lines */ }
+        }
+    }
+
+    // Rollback moves that completed successfully (status === 'done')
+    const toRollback = [...entries.values()]
+        .filter(e => done.has(e.id))
+        .sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+
+    const reversed = [];
+    for (const entry of toRollback) {
+        try {
+            if (fssync.existsSync(entry.destination)) {
+                await fs.rename(entry.destination, entry.source);
+                fssync.appendFileSync(journalPath,
+                    JSON.stringify({ id: entry.id, status: 'rolled-back', rolledBackAt: new Date().toISOString() }) + '\n',
+                    'utf8');
+                reversed.push(entry);
+            }
+        } catch (err) {
+            console.error(`[FAIL] Rollback failed for ${entry.source}: ${err.message}`);
+        }
+    }
+
+    return { reversed, count: reversed.length };
+}
+
+module.exports = FileMayorFS;
+module.exports.JOURNAL_PATH = JOURNAL_PATH;
+module.exports.rollback = rollback;

package/core/guardrail.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — LOGIC GUARDRAIL
+ * 
+ * The final layer of the Chevza Doctrine: INTENTIONALITY.
+ * Sits between the AI Intuition Engine and the Jailer.
+ * Forces a dry-run preview + user confirmation for high-volume
+ * or destructive-pattern operations.
+ * 
+ * Zero-dependency: uses native `readline/promises`.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const readline = require('readline/promises');
+const { stdin: input, stdout: output } = require('process');
+const path = require('path');
+
+class LogicGuardrail {
+    /**
+     * @param {number} safetyLimit - Max ops before triggering confirmation (default: 50)
+     */
+    constructor(safetyLimit = 50) {
+        this.safetyLimit = safetyLimit;
+    }
+
+    /**
+     * Analyze a batch plan and require user confirmation if suspicious.
+     * @param {Array} batch - Array of { source, destination, type?, reason? }
+     * @returns {Promise<boolean>} Whether the user approved the batch
+     */
+    async verifyBatch(batch) {
+        if (!Array.isArray(batch) || batch.length === 0) return true;
+
+        const operationCount = batch.length;
+
+        // Auto-pass for small, safe batches
+        if (operationCount < this.safetyLimit && !this.isDestructivePattern(batch)) {
+            return true;
+        }
+
+        // ─── Dry Run Summary ─────────────────────────────────────
+        console.log('\n' + '═'.repeat(60));
+        console.log('⚠️  [LOGIC GUARDRAIL] High-Volume Operation Detected');
+        console.log('═'.repeat(60));
+        console.log(`   Total operations: ${operationCount}`);
+        console.log(`   Safety limit:     ${this.safetyLimit}`);
+
+        if (this.isDestructivePattern(batch)) {
+            console.log('\n   🔴 WARNING: Destructive pattern detected!');
+            console.log('   Many files are being moved to a single destination.');
+            console.log('   This could indicate an AI "Semantic Wipe" or "Over-Organizer" loop.');
+        }
+
+        // Show preview of first 5 operations
+        console.log('\n   Preview:');
+        const preview = batch.slice(0, 5);
+        for (const op of preview) {
+            const srcName = path.basename(op.source || '');
+            const dstDir = path.dirname(op.destination || '');
+            console.log(`   ${srcName} → ${dstDir}`);
+        }
+        if (operationCount > 5) {
+            console.log(`   ... and ${operationCount - 5} more.`);
+        }
+        console.log('═'.repeat(60));
+
+        // ─── User Confirmation (Native Node.js) ─────────────────
+        const rl = readline.createInterface({ input, output });
+        try {
+            const answer = await rl.question('\n   Proceed with this batch? (y/N): ');
+            return answer.toLowerCase().trim() === 'y';
+        } finally {
+            rl.close();
+        }
+    }
+
+    /**
+     * Detect if the AI is funneling many files into a single destination.
+     * This catches "Over-Organizer Loops" and "Semantic Wipes."
+     * @param {Array} batch - The operation batch
+     * @returns {boolean} True if the pattern looks destructive
+     */
+    isDestructivePattern(batch) {
+        if (batch.length < 10) return false;
+
+        const destDirs = batch.map(b => {
+            const dest = b.destination || '';
+            return path.dirname(dest).toLowerCase();
+        });
+        const uniqueDests = new Set(destDirs).size;
+
+        // If 10+ files all going to 1 directory, it's suspicious
+        return (batch.length / uniqueDests) > 10;
+    }
+
+    /**
+     * Detect "Nesting Hell" — AI creating deeply nested structures
+     * @param {Array} batch - The operation batch
+     * @param {number} maxDepth - Maximum allowed nesting depth (default: 8)
+     * @returns {Array} Entries that exceed the nesting depth
+     */
+    detectNestingHell(batch, maxDepth = 8) {
+        return batch.filter(op => {
+            const dest = op.destination || '';
+            const segments = dest.replace(/\\/g, '/').split('/').filter(s => s.length > 0);
+            return segments.length > maxDepth;
+        });
+    }
+}
+
+module.exports = LogicGuardrail;

package/core/index.js

@@ -1,79 +1,135 @@
-#!/usr/bin/env node
-
-/**
- * ═══════════════════════════════════════════════════════════════════
- * FILEMAYOR CORE — INDEX (Barrel Export)
- * Unified entry point for all core modules
- * ═══════════════════════════════════════════════════════════════════
- */
-
-'use strict';
-
-const scanner = require('./scanner');
-const organizer = require('./organizer');
-const cleaner = require('./cleaner');
-const watcher = require('./watcher');
-const config = require('./config');
-const reporter = require('./reporter');
-const categories = require('./categories');
-const security = require('./security');
-const sopParser = require('./sop-parser');
-
-module.exports = {
-    // Scanner
-    Scanner: scanner.Scanner,
-    scan: scanner.scan,
-    scanByCategory: scanner.scanByCategory,
-    scanSummary: scanner.scanSummary,
-    formatBytes: scanner.formatBytes,
-
-    // Organizer
-    organize: organizer.organize,
-    generatePlan: organizer.generatePlan,
-    executePlan: organizer.executePlan,
-    rollback: organizer.rollback,
-    loadJournal: organizer.loadJournal,
-    NAMING_CONVENTIONS: organizer.NAMING_CONVENTIONS,
-
-    // Cleaner
-    Cleaner: cleaner.Cleaner,
-    findJunk: cleaner.findJunk,
-    deleteJunk: cleaner.deleteJunk,
-    clean: cleaner.clean,
-    JUNK_CATEGORIES: cleaner.JUNK_CATEGORIES,
-
-    // Watcher
-    FileWatcher: watcher.FileWatcher,
-
-    // Config
-    loadConfig: config.loadConfig,
-    findConfigFile: config.findConfigFile,
-    createConfigFile: config.createConfigFile,
-    generateTemplate: config.generateTemplate,
-    validateConfig: config.validateConfig,
-
-    // Reporter
-    reporter,
-
-    // Categories
-    categorize: categories.categorize,
-    getCategories: categories.getCategories,
-    mergeCategories: categories.mergeCategories,
-    DEFAULT_CATEGORIES: categories.DEFAULT_CATEGORIES,
-
-    // Security
-    validatePath: security.validatePath,
-    isFileSafe: security.isFileSafe,
-    isDirSafe: security.isDirSafe,
-    sanitizeFilename: security.sanitizeFilename,
-    checkPermissions: security.checkPermissions,
-
-    // SOP Parser
-    parseSOP: sopParser.parseSOP,
-    parseRuleBased: sopParser.parseRuleBased,
-    rulesToConfig: sopParser.rulesToConfig,
-    FILE_TYPE_ALIASES: sopParser.FILE_TYPE_ALIASES,
-
-    // Version
-    VERSION: require('../package.json').version || '2.0.0'
-};
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — INDEX (Barrel Export)
+ * Unified entry point for all core modules
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const scanner = require('./scanner');
+const organizer = require('./organizer');
+const IntentInterpreter = require('./intent-interpreter');
+const FileMayorFS = require('./fs-abstraction');
+const cleaner = require('./cleaner');
+const watcher = require('./watcher');
+const config = require('./config');
+const reporter = require('./reporter');
+const categories = require('./categories');
+const security = require('./security');
+const sopParser = require('./sop-parser');
+const analyzer = require('./analyzer');
+const license = require('./license');
+const ExplainEngine = require('./engine/explain-engine');
+const CureEngine = require('./engine/cure-engine');
+const ApplyEngine = require('./engine/apply-engine');
+const PreviewEngine = require('./engine/preview-engine');
+const DedupeEngine = require('./engine/dedupe-engine');
+const MetadataStore = require('./metadata-store');
+const strategist = require('./ai/strategist');
+const sentry = require('./ai/sentry');
+const planner = require('./ai/planner');
+const validator = require('./ai/validator');
+const { FileMayorJailer, enforceUserSpace } = require('./jailer');
+const Vault = require('./vault');
+const LogicGuardrail = require('./guardrail');
+const { initEmergencyHalt, updateJournalRef, clearEmergencyHalt } = require('./emergency-halt');
+
+module.exports = {
+    // Scanner
+    Scanner: scanner.Scanner,
+    scan: scanner.scan,
+    scanByCategory: scanner.scanByCategory,
+    scanSummary: scanner.scanSummary,
+    formatBytes: scanner.formatBytes,
+    analyzeDirectory: analyzer.analyzeDirectory,
+
+    // Organizer
+    organize: organizer.organize,
+    generatePlan: organizer.generatePlan,
+    executePlan: organizer.executePlan,
+    rollback: organizer.rollback,
+    loadJournal: organizer.loadJournal,
+    NAMING_CONVENTIONS: organizer.NAMING_CONVENTIONS,
+
+    // Intent Interpreter
+    IntentInterpreter: IntentInterpreter,
+
+    // FS Abstraction
+    FileMayorFS: FileMayorFS,
+
+    // Cleaner
+    Cleaner: cleaner.Cleaner,
+    findJunk: cleaner.findJunk,
+    deleteJunk: cleaner.deleteJunk,
+    clean: cleaner.clean,
+    JUNK_CATEGORIES: cleaner.JUNK_CATEGORIES,
+
+    // Watcher
+    FileWatcher: watcher.FileWatcher,
+
+    // Config
+    loadConfig: config.loadConfig,
+    findConfigFile: config.findConfigFile,
+    createConfigFile: config.createConfigFile,
+    generateTemplate: config.generateTemplate,
+    validateConfig: config.validateConfig,
+
+    // Reporter
+    reporter,
+
+    // Categories
+    categorize: categories.categorize,
+    getCategories: categories.getCategories,
+    mergeCategories: categories.mergeCategories,
+    DEFAULT_CATEGORIES: categories.DEFAULT_CATEGORIES,
+
+    // Security
+    validatePath: security.validatePath,
+    isFileSafe: security.isFileSafe,
+    isDirSafe: security.isDirSafe,
+    sanitizeFilename: security.sanitizeFilename,
+    checkPermissions: security.checkPermissions,
+
+    // SOP Parser
+    parseSOP: sopParser.parseSOP,
+    parseRuleBased: sopParser.parseRuleBased,
+    rulesToConfig: sopParser.rulesToConfig,
+    FILE_TYPE_ALIASES: sopParser.FILE_TYPE_ALIASES,
+
+    // License
+    activateLicense: license.activateLicense,
+    deactivateLicense: license.deactivateLicense,
+    getLicenseInfo: license.getLicenseInfo,
+    checkProFeature: license.checkProFeature,
+    checkBulkLimit: license.checkBulkLimit,
+    hasFeature: license.hasFeature,
+
+    // Intent Agents
+    IntentStrategist: strategist,
+    MetadataSentry: sentry,
+    CurativePlanner: planner,
+    SecurityArchitect: validator,
+
+    // Engines
+    ExplainEngine,
+    CureEngine,
+    ApplyEngine,
+    PreviewEngine,
+    DedupeEngine,
+    MetadataStore,
+
+    // Hardened Runtime
+    FileMayorJailer,
+    enforceUserSpace,
+    Vault,
+    LogicGuardrail,
+    initEmergencyHalt,
+    updateJournalRef,
+    clearEmergencyHalt,
+
+    // Version
+    VERSION: require('../package.json').version || '2.0.0'
+};