filemayor 2.0.0

package/core/config.js

@@ -0,0 +1,562 @@
+#!/usr/bin/env node
+
+/**
+ * ═══════════════════════════════════════════════════════════════════
+ * FILEMAYOR CORE — CONFIG
+ * YAML/JSON config parser with schema validation, merge strategy,
+ * environment variable expansion, and defaults.
+ * ═══════════════════════════════════════════════════════════════════
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// ─── Default Configuration ────────────────────────────────────────
+
+const DEFAULT_CONFIG = {
+    version: 1,
+    organize: {
+        naming: 'original',          // original | category_prefix | date_prefix | clean
+        duplicates: 'rename',        // rename | skip | overwrite
+        maxDepth: 20,
+        includeHidden: false,
+        ignore: [
+            'node_modules', '.git', '__pycache__', '.venv',
+            'dist', 'build', '.next', '.cache'
+        ],
+        categories: {}               // Custom category overrides
+    },
+    clean: {
+        categories: ['temp', 'cache', 'system', 'logs'],
+        maxDepth: 10,
+        includeDirectories: true,
+        customPatterns: {}
+    },
+    watch: {
+        directories: [],
+        debounceMs: 500,
+        recursive: true,
+        autoOrganize: false,
+        rules: [],
+        logPath: null
+    },
+    scanner: {
+        maxDepth: 20,
+        followSymlinks: false,
+        includeHidden: false,
+        ignore: [
+            'node_modules', '.git', '__pycache__', '.venv',
+            'dist', 'build'
+        ],
+        minSize: 0,
+        maxSize: null
+    },
+    output: {
+        format: 'table',             // table | json | csv | minimal
+        colors: true,
+        verbose: false,
+        quiet: false
+    },
+    security: {
+        maxOperationsPerMinute: 1000,
+        confirmDestructive: true,
+        journalEnabled: true,
+        journalPath: '.filemayor-journal.json'
+    }
+};
+
+// ─── Config File Discovery ────────────────────────────────────────
+
+const CONFIG_FILENAMES = [
+    '.filemayor.yml',
+    '.filemayor.yaml',
+    '.filemayor.json',
+    'filemayor.config.js',
+    'filemayor.config.json',
+];
+
+/**
+ * Search for a config file starting from a directory and walking up
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string|null} Path to found config file, or null
+ */
+function findConfigFile(startDir = process.cwd()) {
+    let dir = path.resolve(startDir);
+    const root = path.parse(dir).root;
+
+    while (dir !== root) {
+        for (const filename of CONFIG_FILENAMES) {
+            const configPath = path.join(dir, filename);
+            if (fs.existsSync(configPath)) {
+                return configPath;
+            }
+        }
+        dir = path.dirname(dir);
+    }
+
+    // Check home directory
+    for (const filename of CONFIG_FILENAMES) {
+        const homePath = path.join(os.homedir(), filename);
+        if (fs.existsSync(homePath)) {
+            return homePath;
+        }
+    }
+
+    return null;
+}
+
+// ─── Config Parsing ───────────────────────────────────────────────
+
+/**
+ * Simple YAML parser for FileMayor config files
+ * Supports: strings, numbers, booleans, arrays, nested objects, comments
+ * Does NOT support: anchors, aliases, multi-line strings, flow style
+ * @param {string} yamlContent - YAML string
+ * @returns {Object} Parsed object
+ */
+function parseSimpleYaml(yamlContent) {
+    const lines = yamlContent.split('\n');
+    const result = {};
+    const stack = [{ indent: -1, obj: result }];
+
+    for (let i = 0; i < lines.length; i++) {
+        let line = lines[i];
+
+        // Remove comments (but not # inside quotes)
+        const commentIdx = line.search(/(?<!['"])\s*#/);
+        if (commentIdx >= 0) {
+            line = line.substring(0, commentIdx);
+        }
+
+        // Skip empty lines
+        const trimmed = line.trimEnd();
+        if (trimmed.length === 0) continue;
+
+        // Calculate indent
+        const indent = line.length - line.trimStart().length;
+        const content = trimmed.trim();
+
+        // Handle array items
+        if (content.startsWith('- ')) {
+            const parent = stack[stack.length - 1];
+            const arrayItemValue = content.slice(2).trim();
+
+            // Find the last key that should be an array
+            const parentObj = parent.obj;
+            const keys = Object.keys(parentObj);
+            const lastKey = keys[keys.length - 1];
+
+            if (lastKey && Array.isArray(parentObj[lastKey])) {
+                parentObj[lastKey].push(parseYamlValue(arrayItemValue));
+            } else if (lastKey && parentObj[lastKey] === null) {
+                parentObj[lastKey] = [parseYamlValue(arrayItemValue)];
+            }
+            continue;
+        }
+
+        // Handle key: value
+        const colonIdx = content.indexOf(':');
+        if (colonIdx === -1) continue;
+
+        const key = content.substring(0, colonIdx).trim();
+        const rawValue = content.substring(colonIdx + 1).trim();
+
+        // Pop stack to correct level
+        while (stack.length > 1 && stack[stack.length - 1].indent >= indent) {
+            stack.pop();
+        }
+
+        const currentObj = stack[stack.length - 1].obj;
+
+        if (rawValue === '' || rawValue === null) {
+            // Nested object or array will follow
+            currentObj[key] = {};
+            stack.push({ indent, obj: currentObj[key] });
+        } else if (rawValue.startsWith('[') && rawValue.endsWith(']')) {
+            // Inline array: [item1, item2]
+            const items = rawValue.slice(1, -1).split(',').map(s => parseYamlValue(s.trim()));
+            currentObj[key] = items;
+        } else {
+            currentObj[key] = parseYamlValue(rawValue);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Parse a YAML value to its JS type
+ */
+function parseYamlValue(str) {
+    if (str === 'true') return true;
+    if (str === 'false') return false;
+    if (str === 'null' || str === '~') return null;
+
+    // Remove quotes
+    if ((str.startsWith('"') && str.endsWith('"')) ||
+        (str.startsWith("'") && str.endsWith("'"))) {
+        return str.slice(1, -1);
+    }
+
+    // Numbers
+    if (/^-?\d+(\.\d+)?$/.test(str)) {
+        return parseFloat(str);
+    }
+
+    return str;
+}
+
+/**
+ * Load and parse a config file
+ * @param {string} configPath - Path to config file
+ * @returns {Object} Parsed configuration
+ */
+function loadConfigFile(configPath) {
+    const resolved = path.resolve(configPath);
+
+    if (!fs.existsSync(resolved)) {
+        throw new Error(`Config file not found: ${resolved}`);
+    }
+
+    const content = fs.readFileSync(resolved, 'utf8');
+    const ext = path.extname(resolved).toLowerCase();
+
+    if (ext === '.json') {
+        return JSON.parse(content);
+    }
+
+    if (ext === '.js') {
+        return require(resolved);
+    }
+
+    // YAML
+    return parseSimpleYaml(content);
+}
+
+// ─── Environment Variable Expansion ───────────────────────────────
+
+/**
+ * Expand environment variables and special paths in config values
+ * Supports: $HOME, $USER, ~, ${VAR_NAME}, $VAR_NAME
+ * @param {any} value - Config value (string, array, or object)
+ * @returns {any} Expanded value
+ */
+function expandVariables(value) {
+    if (typeof value === 'string') {
+        return value
+            .replace(/^~(?=[/\\]|$)/, os.homedir())
+            .replace(/\$HOME/g, os.homedir())
+            .replace(/\$USER/g, os.userInfo().username)
+            .replace(/\$\{(\w+)\}/g, (_, name) => process.env[name] || '')
+            .replace(/\$(\w+)/g, (match, name) => {
+                // Don't replace if it looks like a YAML reference
+                if (['HOME', 'USER'].includes(name)) return process.env[name] || '';
+                return process.env[name] !== undefined ? process.env[name] : match;
+            });
+    }
+
+    if (Array.isArray(value)) {
+        return value.map(v => expandVariables(v));
+    }
+
+    if (value && typeof value === 'object') {
+        const result = {};
+        for (const [k, v] of Object.entries(value)) {
+            result[k] = expandVariables(v);
+        }
+        return result;
+    }
+
+    return value;
+}
+
+// ─── Deep Merge ───────────────────────────────────────────────────
+
+/**
+ * Deep merge two objects (source overwrites target)
+ * @param {Object} target - Base object
+ * @param {Object} source - Override object
+ * @returns {Object} Merged result
+ */
+function deepMerge(target, source) {
+    const result = { ...target };
+
+    for (const [key, value] of Object.entries(source)) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            result[key] = deepMerge(result[key] || {}, value);
+        } else {
+            result[key] = value;
+        }
+    }
+
+    return result;
+}
+
+// ─── Config Schema Validation ─────────────────────────────────────
+
+const VALID_NAMING = ['original', 'category_prefix', 'date_prefix', 'clean'];
+const VALID_DUPLICATES = ['rename', 'skip', 'overwrite'];
+const VALID_FORMATS = ['table', 'json', 'csv', 'minimal'];
+const VALID_CLEAN_CATEGORIES = ['temp', 'cache', 'system', 'logs', 'build', 'dependencies', 'ide'];
+
+/**
+ * Validate a config object and return errors
+ * @param {Object} config - Config to validate
+ * @returns {{ valid: boolean, errors: string[], warnings: string[] }}
+ */
+function validateConfig(config) {
+    const errors = [];
+    const warnings = [];
+
+    // Organize
+    if (config.organize) {
+        if (config.organize.naming && !VALID_NAMING.includes(config.organize.naming)) {
+            errors.push(`organize.naming: invalid value "${config.organize.naming}". Valid: ${VALID_NAMING.join(', ')}`);
+        }
+        if (config.organize.duplicates && !VALID_DUPLICATES.includes(config.organize.duplicates)) {
+            errors.push(`organize.duplicates: invalid value "${config.organize.duplicates}". Valid: ${VALID_DUPLICATES.join(', ')}`);
+        }
+        if (config.organize.maxDepth && (typeof config.organize.maxDepth !== 'number' || config.organize.maxDepth < 1)) {
+            errors.push('organize.maxDepth: must be a positive number');
+        }
+        if (config.organize.maxDepth > 50) {
+            warnings.push('organize.maxDepth: values above 50 may cause performance issues');
+        }
+    }
+
+    // Clean
+    if (config.clean) {
+        if (config.clean.categories) {
+            for (const cat of config.clean.categories) {
+                if (!VALID_CLEAN_CATEGORIES.includes(cat)) {
+                    warnings.push(`clean.categories: unknown category "${cat}"`);
+                }
+            }
+        }
+    }
+
+    // Output
+    if (config.output) {
+        if (config.output.format && !VALID_FORMATS.includes(config.output.format)) {
+            errors.push(`output.format: invalid value "${config.output.format}". Valid: ${VALID_FORMATS.join(', ')}`);
+        }
+    }
+
+    // Watch
+    if (config.watch && config.watch.rules) {
+        for (let i = 0; i < config.watch.rules.length; i++) {
+            const rule = config.watch.rules[i];
+            if (!rule.match) {
+                errors.push(`watch.rules[${i}]: missing "match" pattern`);
+            }
+            if (!rule.action) {
+                errors.push(`watch.rules[${i}]: missing "action"`);
+            }
+            if (['move', 'copy'].includes(rule.action) && !rule.dest) {
+                errors.push(`watch.rules[${i}]: action "${rule.action}" requires "dest"`);
+            }
+        }
+    }
+
+    return {
+        valid: errors.length === 0,
+        errors,
+        warnings
+    };
+}
+
+// ─── Main Config Loader ──────────────────────────────────────────
+
+/**
+ * Load full configuration with merge hierarchy:
+ * defaults → user config (~/.filemayor.yml) → project config → CLI flags
+ * @param {Object} options
+ * @returns {{ config: Object, source: string, validation: Object }}
+ */
+function loadConfig(options = {}) {
+    const {
+        configPath = null,         // Explicit config file path
+        cliOverrides = {},         // CLI flag overrides
+        searchDir = process.cwd(), // Where to search for config
+        validate = true            // Run validation
+    } = options;
+
+    let config = { ...DEFAULT_CONFIG };
+    let source = 'defaults';
+
+    // 1. Try to load user-level config from home dir
+    const homeConfig = path.join(os.homedir(), '.filemayor.yml');
+    if (fs.existsSync(homeConfig)) {
+        try {
+            const userConfig = loadConfigFile(homeConfig);
+            config = deepMerge(config, expandVariables(userConfig));
+            source = homeConfig;
+        } catch { /* ignore user config errors */ }
+    }
+
+    // 2. Try to load project-level config
+    const projectConfig = configPath || findConfigFile(searchDir);
+    if (projectConfig && projectConfig !== homeConfig) {
+        try {
+            const projConfig = loadConfigFile(projectConfig);
+            config = deepMerge(config, expandVariables(projConfig));
+            source = projectConfig;
+        } catch (err) {
+            if (configPath) {
+                // Explicit path — throw
+                throw new Error(`Failed to load config: ${err.message}`);
+            }
+            // Auto-discovered — ignore
+        }
+    }
+
+    // 3. Apply CLI overrides
+    if (Object.keys(cliOverrides).length > 0) {
+        config = deepMerge(config, cliOverrides);
+        source = `${source} + CLI flags`;
+    }
+
+    // 4. Validate
+    let validation = { valid: true, errors: [], warnings: [] };
+    if (validate) {
+        validation = validateConfig(config);
+    }
+
+    return { config, source, validation };
+}
+
+// ─── Config Template Generation ──────────────────────────────────
+
+/**
+ * Generate a default .filemayor.yml template
+ * @returns {string} YAML config template
+ */
+function generateTemplate() {
+    return `# ═══════════════════════════════════════════════════════════
+# FileMayor Configuration
+# Place this file in your project root or home directory
+# ═══════════════════════════════════════════════════════════
+
+version: 1
+
+# ─── File Organization ─────────────────────────────────────
+organize:
+  # Naming convention: original | category_prefix | date_prefix | clean
+  naming: original
+
+  # Duplicate handling: rename | skip | overwrite
+  duplicates: rename
+
+  # Max directory depth to scan
+  maxDepth: 20
+
+  # Include hidden files (starting with .)
+  includeHidden: false
+
+  # Directories to ignore
+  ignore: [node_modules, .git, __pycache__, .venv, dist, build, .next, .cache]
+
+  # Custom category overrides (merge with defaults)
+  # categories:
+  #   reports:
+  #     label: Reports
+  #     extensions: [.report, .summary]
+  #     color: "#ff6b6b"
+
+# ─── System Cleaner ────────────────────────────────────────
+clean:
+  # Junk categories to scan: temp, cache, system, logs, build, dependencies, ide
+  categories: [temp, cache, system, logs]
+
+  # Max depth for junk scanning
+  maxDepth: 10
+
+  # Include junk directories (node_modules, .cache, etc.)
+  includeDirectories: true
+
+# ─── File Watcher (Daemon Mode) ────────────────────────────
+watch:
+  # Directories to watch
+  directories: []
+
+  # Debounce delay for rapid changes (ms)
+  debounceMs: 500
+
+  # Watch subdirectories
+  recursive: true
+
+  # Auto-organize on new files
+  autoOrganize: false
+
+  # Rules engine
+  # rules:
+  #   - match: "*.pdf"
+  #     action: move
+  #     dest: ~/Documents/PDFs
+  #   - match: "*.{jpg,png,gif}"
+  #     action: move
+  #     dest: ~/Pictures
+  #   - match: "@code"
+  #     action: log
+
+# ─── Output Formatting ─────────────────────────────────────
+output:
+  # Format: table | json | csv | minimal
+  format: table
+
+  # Enable colors
+  colors: true
+
+  # Verbose logging
+  verbose: false
+
+  # Suppress all output (exit code only)
+  quiet: false
+
+# ─── Security ──────────────────────────────────────────────
+security:
+  # Max file operations per minute
+  maxOperationsPerMinute: 1000
+
+  # Require confirmation for destructive operations
+  confirmDestructive: true
+
+  # Enable operation journal for undo
+  journalEnabled: true
+
+  # Journal file path (relative to working directory)
+  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
+ * @returns {string} Path to created file
+ */
+function createConfigFile(dir = process.cwd(), filename = '.filemayor.yml') {
+    const configPath = path.join(dir, filename);
+    if (fs.existsSync(configPath)) {
+        throw new Error(`Config file already exists: ${configPath}`);
+    }
+    fs.writeFileSync(configPath, generateTemplate(), 'utf8');
+    return configPath;
+}
+
+module.exports = {
+    DEFAULT_CONFIG,
+    CONFIG_FILENAMES,
+    findConfigFile,
+    loadConfigFile,
+    loadConfig,
+    validateConfig,
+    deepMerge,
+    expandVariables,
+    parseSimpleYaml,
+    generateTemplate,
+    createConfigFile
+};

package/core/index.js

@@ -0,0 +1,79 @@
+#!/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'
+};