filemayor 2.0.5 → 3.6.0

package/core/fs-abstraction.js

@@ -0,0 +1,199 @@
+#!/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.json'),
+            ...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 });
+
+            try {
+                await fs.rename(source, destination);
+            } catch (err) {
+                if (err.code === 'EXDEV') {
+                    await fs.copyFile(source, destination);
+                    await fs.unlink(source);
+                } else throw err;
+            }
+
+            result.status = 'success';
+            this.stats.opsSucceeded++;
+            this.stats.filesMoved++;
+            this.stats.totalBytesProcessed += snapshot.size || 0;
+            await this._logToJournal(source, destination, 'move', snapshot);
+
+        } 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
+     * -------------------------*/
+    async _logToJournal(source, destination, action, snapshot) {
+        if (!this.options.useJournal) return;
+
+        const entry = {
+            id: crypto.randomUUID(),
+            timestamp: new Date().toISOString(),
+            action,
+            source,
+            destination,
+            snapshot
+        };
+
+        this.sessionJournal.push(entry);
+
+        // Persistent Journaling (v3.5)
+        try {
+            let diskJournal = [];
+            if (fssync.existsSync(this.options.journalPath)) {
+                diskJournal = JSON.parse(fssync.readFileSync(this.options.journalPath, 'utf8'));
+            }
+            diskJournal.push(entry);
+            // Save last 1000 ops globally
+            fssync.writeFileSync(this.options.journalPath, JSON.stringify(diskJournal.slice(-1000), null, 2));
+        } catch (err) {
+            console.error(`[FAIL] Disk Journal write failed: ${err.message}`);
+        }
+    }
+
+    /** ------------------------
+     * Rollback
+     * -------------------------*/
+    async rollback() {
+        // Use session journal if available, otherwise try to load from disk
+        let reversed = [...this.sessionJournal].reverse();
+        
+        if (reversed.length === 0 && fssync.existsSync(this.options.journalPath)) {
+            console.log(`[SYS] Session journal empty. Attempting disk rollback...`);
+            const diskJournal = JSON.parse(fssync.readFileSync(this.options.journalPath, 'utf8'));
+            reversed = diskJournal.reverse();
+        }
+
+        console.log(`[SYS] Rolling back ${reversed.length} operations...`);
+
+        for (const entry of reversed) {
+            try {
+                if (entry.action === 'move') {
+                    if (fssync.existsSync(entry.destination)) {
+                        await fs.rename(entry.destination, entry.source);
+                    }
+                } else if (entry.action === 'delete') {
+                    if (fssync.existsSync(entry.destination)) {
+                        await fs.rename(entry.destination, entry.source);
+                    }
+                }
+            } catch (err) {
+                console.error(`[FAIL] Rollback failed for ${entry.source}: ${err.message}`);
+            }
+        }
+
+        this.sessionJournal = [];
+        console.log(`[SYS] Rollback complete.`);
+    }
+
+    getJournal() {
+        return this.sessionJournal;
+    }
+}
+
+module.exports = FileMayorFS;

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

@@ -11,6 +11,8 @@
 
 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');
@@ -18,6 +20,22 @@ 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
@@ -26,6 +44,7 @@ module.exports = {
     scanByCategory: scanner.scanByCategory,
     scanSummary: scanner.scanSummary,
     formatBytes: scanner.formatBytes,
+    analyzeDirectory: analyzer.analyzeDirectory,
 
     // Organizer
     organize: organizer.organize,
@@ -35,6 +54,12 @@ module.exports = {
     loadJournal: organizer.loadJournal,
     NAMING_CONVENTIONS: organizer.NAMING_CONVENTIONS,
 
+    // Intent Interpreter
+    IntentInterpreter: IntentInterpreter,
+
+    // FS Abstraction
+    FileMayorFS: FileMayorFS,
+
     // Cleaner
     Cleaner: cleaner.Cleaner,
     findJunk: cleaner.findJunk,
@@ -74,6 +99,37 @@ module.exports = {
     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'
 };

package/core/intent-interpreter.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR v3.0 — INTENT INTERPRETER
+ * AI Logic Layer: Bridges fuzzy human language and atomic execution.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const path = require('path');
+
+const GEMINI_MODEL = 'gemini-2.0-flash';
+const GEMINI_ENDPOINT = `https://generativelanguage.googleapis.com/v1beta/models/${GEMINI_MODEL}:generateContent`;
+
+class IntentInterpreter {
+    constructor(apiKey) {
+        this.apiKey = apiKey || process.env.GEMINI_API_KEY;
+        if (!this.apiKey) {
+            console.warn('[WARN] GEMINI_API_KEY not found. AI features will be disabled.');
+        }
+    }
+
+    /**
+     * Interpret a user prompt against clustered telemetry
+     * @param {string} userPrompt
+     * @param {Object} clusters - From MetadataSentry
+     * @param {Object} context
+     * @returns {Promise<Object>} The Curative Plan
+     */
+    async interpret(userPrompt, clusters, context = {}) {
+        if (!this.apiKey) {
+            throw new Error('API Key missing. Cannot interpret intent.');
+        }
+
+        const telemetry = this._summarizeFiles(clusters);
+        const systemPrompt = this._getSystemPrompt(context);
+
+        const response = await this._callGemini(systemPrompt, userPrompt, telemetry);
+        const curativePlan = this._parseResponse(response);
+
+        // [Production Grade] Confidence Gating
+        if (curativePlan.confidence < 60) {
+            curativePlan.status = 'low_confidence';
+            curativePlan.message = 'I am not entirely sure about this request. Could you clarify your intent?';
+        }
+
+        // [Production Grade] Plan Validation
+        curativePlan.plan = this._validatePlan(curativePlan.plan);
+
+        return curativePlan;
+    }
+
+    /**
+     * Summarize clustered file list for AI ingestion
+     */
+    _summarizeFiles(clusters) {
+        const summary = {};
+        
+        for (const cat in clusters) {
+            summary[cat] = {
+                count: clusters[cat].count,
+                samples: clusters[cat].samples.map(s => ({
+                    name: s.name,
+                    path: s.path,
+                    ancestry: s.ancestry,
+                    bundleId: s.bundleId
+                }))
+            };
+        }
+        
+        return summary;
+    }
+
+    _getSystemPrompt(context) {
+        return `You are FileMayor v3.2, the "Intuition & Dependency Engine".
+Your goal is to organize files while strictly preserving the integrity of projects and collections.
+
+INPUT:
+1. User Intent: "${context.intent}" (Strategy: "${context.strategy}")
+2. Telemetry: Clustered file metadata including 'ancestry' and 'bundleId'.
+
+GOLDEN RULES:
+- RULE OF ANCESTRY: Respect parent directory names in 'ancestry'. If a file is in /Books/ or a project folder, DO NOT scatter it based on extension alone.
+- ATOMIC BUNDLING: Files sharing a 'bundleId' (like music stems with a project file) MUST stay together.
+- REFINE, DON'T DESTROY: A "Refine" intent means improving structure WITHIN a domain, not extracting files OUT of it. 
+- FORMAT: Return a VALID JSON object. Use absolute paths for source.
+
+OUTPUT SCHEMA:
+{
+  "narrative": "A curative explanation of the structural refinement.",
+  "plan": [
+    { "source": "absolute/path", "destination": "suggested/target", "reason": "Why?" }
+  ],
+  "confidence": 0-100
+}`;
+    }
+
+    async _callGemini(systemPrompt, userPrompt, files) {
+        const body = {
+            contents: [{
+                parts: [{
+                    text: `${systemPrompt}\n\nUSER INTENT: "${userPrompt}"\n\nFILES:\n${JSON.stringify(files, null, 2)}`
+                }]
+            }],
+            generationConfig: {
+                temperature: 0.1, // Even lower for higher determinism
+                topP: 0.95,
+                maxOutputTokens: 2048,
+                responseMimeType: "application/json" // [Production Grade] Force JSON Mode
+            }
+        };
+
+        const url = `${GEMINI_ENDPOINT}?key=${this.apiKey}`;
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(body),
+        });
+
+        if (!response.ok) {
+            const err = await response.text();
+            throw new Error(`Gemini API Error: ${response.status} - ${err}`);
+        }
+
+        const data = await response.json();
+        return data?.candidates?.[0]?.content?.parts?.[0]?.text || '';
+    }
+
+    /**
+     * Validate plan entries from AI response
+     * Filters out any entries missing required fields
+     */
+    _validatePlan(plan) {
+        if (!Array.isArray(plan)) return [];
+        return plan.filter(entry => {
+            if (!entry || typeof entry !== 'object') return false;
+            if (!entry.source || typeof entry.source !== 'string') return false;
+            if (!entry.destination || typeof entry.destination !== 'string') return false;
+            if (!entry.reason) entry.reason = 'AI suggested move';
+            return true;
+        });
+    }
+
+    _parseResponse(rawText) {
+        try {
+            const jsonMatch = rawText.match(/\{[\s\S]*\}/);
+            if (!jsonMatch) throw new Error('No JSON found in AI response');
+            return JSON.parse(jsonMatch[0]);
+        } catch (err) {
+            console.error('[FAIL] Failed to parse AI response:', rawText);
+            throw new Error(`AI Parsing Error: ${err.message}`);
+        }
+    }
+}
+
+module.exports = IntentInterpreter;