filemayor 4.0.7 → 4.0.9

package/core/ai/planner.js

@@ -30,10 +30,21 @@ class CurativePlanner {
             cwd: process.cwd()
         };
 
+        // PARA (v4.0.9): give every provider the same hard contract so the
+        // plan lands in the four buckets and survives validation.
+        let prompt = rawPrompt;
+        if (intent.strategy === 'para_actionability') {
+            prompt = `${rawPrompt}\n\nSort by ACTIONABILITY using the PARA method. HARD RULES:\n` +
+                `- Every destination path MUST begin with exactly one of: Projects/, Areas/, Resources/, Archives/.\n` +
+                `- Projects = active efforts with an end; Areas = ongoing responsibilities (finances, health, home); ` +
+                `Resources = reference material; Archives = anything inactive or untouched for 12+ months.\n` +
+                `- Keep project folders intact (never split a code or media project).`;
+        }
+
         // Standardized Bridge: Telemetry is passed as clusters
         return await this.interpreter.interpret(
-            rawPrompt,
-            sentryData.clusters, 
+            prompt,
+            sentryData.clusters,
             context
         );
     }

package/core/ai/strategist.js

@@ -67,6 +67,14 @@ const ARCHETYPES = {
         nameSignals: ['book', 'chapter', 'isbn', 'edition', 'vol_', 'author'],
         strategy: 'ancestry_matching',
         hierarchy: 'Genre / Subject → Author → Title'
+    },
+    para: {
+        label: 'PARA (actionability)',
+        extSignals: [],
+        nameSignals: ['para'],
+        strategy: 'para_actionability',
+        hierarchy: 'Projects / Areas / Resources / Archives',
+        folders: ['Projects', 'Areas', 'Resources', 'Archives']
     }
 };
 
@@ -83,7 +91,13 @@ class IntentStrategist {
 
         const isRefine = p.includes('refine') || p.includes('structure') || p.includes('within');
 
-        if (p.includes('clean') || p.includes('space') || p.includes('junk')) {
+        // PARA must be detected FIRST — its prompts contain "projects",
+        // which the technical/codebase branch below would otherwise claim.
+        if (p.includes('para') || p.includes('actionability') || (p.includes('areas') && p.includes('archives'))) {
+            intent = 'para_sort';
+            strategy = 'para_actionability';
+            archetype = 'para';
+        } else if (p.includes('clean') || p.includes('space') || p.includes('junk')) {
             intent = 'cleanup';
             strategy = 'retention';
         } else if (p.includes('tax') || p.includes('invoice') || p.includes('receipt')) {

package/core/ai/validator.js

@@ -29,6 +29,11 @@ class SecurityArchitect {
         }
 
         const domainTriggerFolders = ['books', 'library', 'projects', 'music', 'work', 'downloads'];
+        // PARA buckets (v4.0.9): a deliberate re-filing INTO one of the four
+        // actionability buckets is not "domain scattering" — it is the point
+        // of a PARA plan. Destinations rooted in a bucket bypass only the
+        // domain-preservation rule; path-safety and bundle locks still apply.
+        const paraBuckets = new Set(['projects', 'areas', 'resources', 'archives']);
         const clusters = sentryData?.clusters || {};
         const allSamples = Object.values(clusters).flatMap(c => c.samples || []);
         const homeParts = this._homePrefixParts;
@@ -54,14 +59,15 @@ class SecurityArchitect {
                 const destParts = normalize(step.destination);
 
                 const triggerFound = srcParts.find(p => domainTriggerFolders.includes(p));
+                const destIsParaBucket = destParts.some(p => paraBuckets.has(p));
 
-                if (triggerFound) {
+                if (triggerFound && !destIsParaBucket) {
                     // A move is valid if the EXACT trigger folder is present in the destination path
                     const preserved = destParts.includes(triggerFound);
 
-                    if (!preserved && !step.reason.includes('COLLECTION_MOVE')) {
+                    if (!preserved && !(step.reason || '').includes('COLLECTION_MOVE')) {
                         console.warn(`[ARCHITECTURE] Blocked domain scattering for ${step.source} -> ${step.destination}`);
-                        return false; 
+                        return false;
                     }
                 }
 

package/core/cleaner.js

@@ -394,18 +394,24 @@ class Cleaner {
 // ─── Deletion ─────────────────────────────────────────────────────
 
 /**
- * Delete junk files and directories
+ * Delete junk files and directories — trash-based and journaled, so
+ * `filemayor undo` restores anything removed by mistake (v4.0.9; this
+ * used to unlink/rmSync permanently).
  * @param {Object[]} junkItems - Items from findJunk
  * @param {Object} options - Deletion options
- * @returns {{ deleted: number, freed: number, freedHuman: string, errors: Object[] }}
+ * @returns {Promise<{ deleted: number, freed: number, freedHuman: string, errors: Object[] }>}
  */
-function deleteJunk(junkItems, options = {}) {
+async function deleteJunk(junkItems, options = {}) {
     const {
         onProgress = null,
         onError = null,
         filterCategories = null, // Only delete these categories
+        fmfs = null,             // Shared FileMayorFS (one undo session per clean run)
     } = options;
 
+    const FileMayorFS = require('./fs-abstraction');
+    const trashFs = fmfs || new FileMayorFS();
+
     let deleted = 0;
     let freed = 0;
     const errors = [];
@@ -437,7 +443,7 @@ function deleteJunk(junkItems, options = {}) {
             if (!canWrite(path.dirname(item.path))) {
                 throw new Error('Permission denied');
             }
-            fs.unlinkSync(item.path);
+            await trashFs.delete(item.path);
             deleted++;
             freed += item.size;
         } catch (err) {
@@ -447,7 +453,7 @@ function deleteJunk(junkItems, options = {}) {
         }
     }
 
-    // Delete directories (sort by depth descending — deepest first)
+    // Trash 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;
@@ -456,11 +462,7 @@ function deleteJunk(junkItems, options = {}) {
 
     for (const dir of sortedDirs) {
         try {
-            if (dir.type === 'empty_directory') {
-                fs.rmdirSync(dir.path);
-            } else {
-                fs.rmSync(dir.path, { recursive: true, force: true });
-            }
+            await trashFs.delete(dir.path);
             deleted++;
             freed += dir.size;
         } catch (err) {
@@ -473,7 +475,10 @@ function deleteJunk(junkItems, options = {}) {
         freed,
         freedHuman: formatBytes(freed),
         errors,
-        total: toDelete.length
+        total: toDelete.length,
+        reversible: true,
+        trashPath: trashFs.options.trashPath,
+        sessionId: trashFs.sessionId
     };
 }
 
@@ -488,9 +493,9 @@ function findJunk(dirPath, options = {}) {
 }
 
 /**
- * Quick clean: scan + delete in one call
+ * Quick clean: scan + trash in one call (reversible with undo)
  */
-function clean(dirPath, options = {}) {
+async function clean(dirPath, options = {}) {
     const { dryRun = false, filterCategories = null, ...scanOptions } = options;
 
     const result = findJunk(dirPath, scanOptions);
@@ -504,7 +509,7 @@ function clean(dirPath, options = {}) {
         };
     }
 
-    const deleteResult = deleteJunk(result.junk, {
+    const deleteResult = await deleteJunk(result.junk, {
         filterCategories,
         onProgress: scanOptions.onProgress,
         onError: scanOptions.onError,

package/core/config.js

@@ -532,18 +532,78 @@ security:
 `;
 }
 
+/**
+ * Generate a PARA-method .filemayor.yml template.
+ * PARA (Projects, Areas, Resources, Archives) is an actionability-based
+ * organizing method; this preset tunes the sorter.
+ * @returns {string} YAML config template
+ */
+function generateParaTemplate() {
+    return `# ═══════════════════════════════════════════════════════════
+# FileMayor Configuration — PARA preset
+# PARA = Projects · Areas · Resources · Archives.
+# FileMayor automates it by sorting files on actionability signals.
+# Run:  filemayor para .        (preview the plan)
+#       filemayor apply         (execute, fully reversible)
+# ═══════════════════════════════════════════════════════════
+
+version: 1
+
+# ─── PARA Actionability Sorter ─────────────────────────────
+para:
+  # Files not modified in this many months are moved to Archives.
+  archiveAfterMonths: 12
+
+  # Files modified within this window count as active → Projects.
+  activeWithinMonths: 3
+
+  # Where files with no clear signal land: projects|areas|resources|archives
+  defaultBucket: resources
+
+  # Keep the top-level subfolder name as a grouping inside each bucket.
+  preserveSubfolders: true
+
+  # Bucket folder names (rename or localize freely).
+  folders:
+    projects: Projects
+    areas: Areas
+    resources: Resources
+    archives: Archives
+
+  # Folder/name words that signal an ongoing responsibility (Areas).
+  areaKeywords: [finance, finances, tax, taxes, invoice, invoices, receipt, insurance, health, medical, home, car, contract, contracts, legal, admin, hr, utilities]
+
+  # File categories that are reference material by nature (Resources).
+  resourceCategories: [books, fonts, design]
+
+  # Folder/name words that signal reference material (Resources).
+  resourceKeywords: [reference, template, templates, manual, manuals, docs, research, notes, inspiration, assets, library, guide, guides]
+
+  # Folder/name words that signal active efforts (Projects).
+  projectKeywords: [project, projects, client, launch, campaign, sprint, deliverable, proposal, draft]
+
+# ─── Security ──────────────────────────────────────────────
+security:
+  confirmDestructive: true
+  journalEnabled: true
+  journalPath: .filemayor-journal.json
+`;
+}
+
 /**
  * Create a config file in the specified directory
  * @param {string} dir - Directory to create config in
  * @param {string} filename - Config filename
+ * @param {string} preset - Template preset: 'default' | 'para'
  * @returns {string} Path to created file
  */
-function createConfigFile(dir = process.cwd(), filename = '.filemayor.yml') {
+function createConfigFile(dir = process.cwd(), filename = '.filemayor.yml', preset = 'default') {
     const configPath = path.join(dir, filename);
     if (fs.existsSync(configPath)) {
         throw new Error(`Config file already exists: ${configPath}`);
     }
-    fs.writeFileSync(configPath, generateTemplate(), 'utf8');
+    const template = preset === 'para' ? generateParaTemplate() : generateTemplate();
+    fs.writeFileSync(configPath, template, 'utf8');
     return configPath;
 }
 
@@ -558,5 +618,6 @@ module.exports = {
     expandVariables,
     parseSimpleYaml,
     generateTemplate,
+    generateParaTemplate,
     createConfigFile
 };

package/core/engine/dedupe-engine.js

@@ -3,43 +3,125 @@
 const { scan, formatBytes } = require('../scanner');
 const crypto = require('crypto');
 const fs = require('fs');
+const fsp = require('fs').promises;
+const FileMayorFS = require('../fs-abstraction');
+
+const PARTIAL_BYTES = 64 * 1024; // head sample for the cheap pass
+const HASH_CONCURRENCY = 8;      // parallel file reads for hashing
+
+/** Run an async mapper over items with bounded concurrency. */
+async function pooled(items, limit, fn) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const i = next++;
+            results[i] = await fn(items[i], i);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+
+/** SHA-1 of the first PARTIAL_BYTES of a file (cheap collision filter). */
+async function partialHash(filePath) {
+    const fd = await fsp.open(filePath, 'r');
+    try {
+        const buf = Buffer.alloc(PARTIAL_BYTES);
+        const { bytesRead } = await fd.read(buf, 0, PARTIAL_BYTES, 0);
+        return crypto.createHash('sha1').update(buf.subarray(0, bytesRead)).digest('hex');
+    } finally {
+        await fd.close();
+    }
+}
+
+/** Streaming SHA-1 of the whole file — constant memory at any size. */
+function fullHash(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = crypto.createHash('sha1');
+        fs.createReadStream(filePath)
+            .on('data', (chunk) => hash.update(chunk))
+            .on('end', () => resolve(hash.digest('hex')))
+            .on('error', reject);
+    });
+}
 
 /**
- * DedupeEngine — specialized engine for finding and removing duplicates
+ * DedupeEngine — finds and removes duplicate files.
+ *
+ * v4.0.9: detection is genuinely content-based (it used to match on
+ * size+name, despite the docs saying "hash-based"). Three-stage pipeline
+ * keeps it fast on huge folders:
+ *   1. size buckets   — only sizes shared by 2+ files go further
+ *   2. partial hash   — first 64 KB, eliminates most collisions cheaply
+ *   3. full hash      — streamed, only for files whose heads collide
+ * Removal is trash-based and journaled: `filemayor undo` restores.
  */
 class DedupeEngine {
-    constructor() {}
+    constructor(options = {}) {
+        this.fmfs = options.fmfs || new FileMayorFS(options.fsOptions || {});
+    }
 
     /**
-     * Find duplicates in a directory
-     * @param {string} dirPath 
-     * @returns {Object} Duplicate report
+     * Find duplicates in a directory (content-hash based).
+     * @param {string} dirPath
+     * @returns {Promise<Object>} Duplicate report
      */
-    find(dirPath) {
+    async find(dirPath) {
         const result = scan(dirPath, { maxDepth: 10 });
-        const map = new Map();
-        const duplicates = [];
-        let totalWasted = 0;
 
+        // Stage 1 — size buckets. A file can only duplicate a same-sized file.
+        const bySize = new Map();
         for (const file of result.files) {
-            // Heuristic-based match (size + name)
-            // In a real pro version, we might do checksums here, 
-            // but for a fast CLI, this is the "Viral" speed way.
-            const key = `${file.size}-${file.name}`;
-            if (map.has(key)) {
-                const original = map.get(key);
-                duplicates.push({
-                    original,
-                    duplicate: file
-                });
-                totalWasted += file.size;
-            } else {
-                map.set(key, file);
+            if (!file.size) continue; // zero-byte files: skip (all "identical", rarely useful)
+            if (!bySize.has(file.size)) bySize.set(file.size, []);
+            bySize.get(file.size).push(file);
+        }
+        const candidates = [...bySize.values()].filter(g => g.length > 1).flat();
+
+        // Stage 2 — partial hash over candidates only.
+        const partials = await pooled(candidates, HASH_CONCURRENCY, async (f) => {
+            try { return `${f.size}:${await partialHash(f.path)}`; } catch { return null; }
+        });
+        const byPartial = new Map();
+        candidates.forEach((f, i) => {
+            const key = partials[i];
+            if (!key) return;
+            if (!byPartial.has(key)) byPartial.set(key, []);
+            byPartial.get(key).push(f);
+        });
+        const finalists = [...byPartial.values()].filter(g => g.length > 1).flat();
+
+        // Stage 3 — full streamed hash for head-colliders.
+        const fulls = await pooled(finalists, HASH_CONCURRENCY, async (f) => {
+            try { return `${f.size}:${await fullHash(f.path)}`; } catch { return null; }
+        });
+        const byFull = new Map();
+        finalists.forEach((f, i) => {
+            const key = fulls[i];
+            if (!key) return;
+            if (!byFull.has(key)) byFull.set(key, []);
+            byFull.get(key).push(f);
+        });
+
+        const duplicates = [];
+        let totalWasted = 0;
+        for (const group of byFull.values()) {
+            if (group.length < 2) continue;
+            // Keep the oldest copy as the original; the rest are duplicates.
+            group.sort((a, b) => new Date(a.modified) - new Date(b.modified));
+            const original = group[0];
+            for (const dupe of group.slice(1)) {
+                duplicates.push({ original, duplicate: dupe });
+                totalWasted += dupe.size;
             }
         }
 
         return {
             path: dirPath,
+            method: 'content-hash',
+            scanned: result.files.length,
+            hashed: finalists.length,
             sets: duplicates.length,
             totalWasted,
             totalWastedHuman: formatBytes(totalWasted),
@@ -48,7 +130,8 @@ class DedupeEngine {
     }
 
     /**
-     * Remove duplicates based on a report
+     * Remove duplicates from a report. Trash-based: every removal is
+     * journaled and reversible with `filemayor undo`.
      */
     async clean(report) {
         let deleted = 0;
@@ -57,7 +140,7 @@ class DedupeEngine {
 
         for (const set of report.duplicates) {
             try {
-                fs.unlinkSync(set.duplicate.path);
+                await this.fmfs.delete(set.duplicate.path);
                 deleted++;
                 freed += set.duplicate.size;
             } catch (err) {
@@ -69,7 +152,10 @@ class DedupeEngine {
             deleted,
             freed,
             freedHuman: formatBytes(freed),
-            errors
+            errors,
+            reversible: true,
+            trashPath: this.fmfs.options.trashPath,
+            sessionId: this.fmfs.sessionId
         };
     }
 }