@vibecheckai/cli 3.5.0 → 3.5.2

package/bin/runners/lib/rules/custom-rule-engine.js

@@ -1,985 +0,0 @@
-/**
- * Custom Rule DSL Engine
- * 
- * ═══════════════════════════════════════════════════════════════════════════════
- * COMPETITIVE MOAT FEATURE - User-Defined Detection Rules
- * ═══════════════════════════════════════════════════════════════════════════════
- * 
- * This engine allows users to create custom detection rules using a simple DSL.
- * Rules can be shared with the community via a marketplace.
- * 
- * Features:
- * - Simple, readable rule syntax
- * - Pattern matching (regex, glob, AST)
- * - Context-aware conditions
- * - Custom fix suggestions
- * - Rule composition (extend/override)
- * - Marketplace publishing/installing
- * - Team rule sharing
- * 
- * Example rule:
- * ```yaml
- * name: no-console-in-api
- * description: Console statements should not be in API routes
- * severity: WARN
- * match:
- *   file: "api/**\/*.ts"
- *   pattern: "console\\.(log|warn|error)"
- * exclude:
- *   - "**\/*.test.ts"
- * fix:
- *   suggestion: "Use a proper logger instead of console"
- *   autofix: "logger.$1"
- * ```
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-const crypto = require("crypto");
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// RULE SCHEMA
-// ═══════════════════════════════════════════════════════════════════════════════
-
-const RULE_SCHEMA = {
-  // Required fields
-  name: { type: "string", required: true },
-  description: { type: "string", required: true },
-  severity: { type: "enum", values: ["BLOCK", "WARN", "INFO"], default: "WARN" },
-  
-  // Match conditions (at least one required)
-  match: {
-    type: "object",
-    properties: {
-      file: { type: "glob" },           // File pattern to match
-      pattern: { type: "regex" },       // Code pattern to match
-      ast: { type: "ast-query" },       // AST selector
-      content: { type: "string" },      // Literal content match
-      import: { type: "string" },       // Import statement match
-      call: { type: "string" },         // Function call match
-      comment: { type: "regex" }        // Comment pattern match
-    }
-  },
-  
-  // Exclude conditions
-  exclude: {
-    type: "array",
-    items: { type: "glob" }
-  },
-  
-  // Context conditions
-  context: {
-    type: "object",
-    properties: {
-      framework: { type: "array" },     // Only apply for these frameworks
-      language: { type: "array" },      // Only apply for these languages
-      env: { type: "string" },          // Only in production/development
-      inside: { type: "string" },       // Must be inside (function, class, etc.)
-      notInside: { type: "string" }     // Must NOT be inside
-    }
-  },
-  
-  // Fix suggestion
-  fix: {
-    type: "object",
-    properties: {
-      suggestion: { type: "string" },   // Human-readable fix suggestion
-      autofix: { type: "string" },      // Autofix replacement pattern
-      dangerous: { type: "boolean" }    // Is autofix potentially dangerous?
-    }
-  },
-  
-  // Metadata
-  meta: {
-    type: "object",
-    properties: {
-      author: { type: "string" },
-      version: { type: "string" },
-      tags: { type: "array" },
-      docs: { type: "string" }
-    }
-  }
-};
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// RULE PARSER
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class RuleParser {
-  /**
-   * Parse a rule definition
-   */
-  static parse(ruleDefinition) {
-    // Support YAML-like format or JSON
-    let rule;
-    
-    if (typeof ruleDefinition === "string") {
-      // Try to parse as simplified DSL
-      rule = this.parseDSL(ruleDefinition);
-    } else {
-      rule = ruleDefinition;
-    }
-
-    // Validate required fields
-    if (!rule.name) {
-      throw new Error("Rule must have a name");
-    }
-    if (!rule.description) {
-      throw new Error("Rule must have a description");
-    }
-    if (!rule.match) {
-      throw new Error("Rule must have at least one match condition");
-    }
-
-    // Apply defaults
-    rule.severity = rule.severity || "WARN";
-    rule.exclude = rule.exclude || [];
-    rule.context = rule.context || {};
-    rule.fix = rule.fix || {};
-    rule.meta = rule.meta || {};
-
-    // Compile patterns
-    rule._compiled = this.compileRule(rule);
-
-    return rule;
-  }
-
-  /**
-   * Parse simplified DSL format
-   */
-  static parseDSL(dsl) {
-    const lines = dsl.split("\n");
-    const rule = {};
-    let currentSection = null;
-    let currentIndent = 0;
-
-    for (const line of lines) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-
-      const indent = line.search(/\S/);
-      const keyMatch = trimmed.match(/^(\w+):\s*(.*)$/);
-      
-      if (keyMatch) {
-        const [, key, value] = keyMatch;
-        
-        if (indent === 0) {
-          // Top-level key
-          if (value) {
-            rule[key] = this.parseValue(value);
-          } else {
-            rule[key] = {};
-            currentSection = key;
-          }
-          currentIndent = indent;
-        } else if (currentSection) {
-          // Nested key
-          if (typeof rule[currentSection] !== "object") {
-            rule[currentSection] = {};
-          }
-          rule[currentSection][key] = this.parseValue(value);
-        }
-      } else if (trimmed.startsWith("-")) {
-        // Array item
-        const itemValue = trimmed.slice(1).trim();
-        if (currentSection) {
-          if (!Array.isArray(rule[currentSection])) {
-            rule[currentSection] = [];
-          }
-          rule[currentSection].push(this.parseValue(itemValue));
-        }
-      }
-    }
-
-    return rule;
-  }
-
-  /**
-   * Parse a value (string, number, boolean, etc.)
-   */
-  static parseValue(value) {
-    if (!value) return null;
-    
-    // Remove quotes
-    if ((value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))) {
-      return value.slice(1, -1);
-    }
-    
-    // Boolean
-    if (value === "true") return true;
-    if (value === "false") return false;
-    
-    // Number
-    if (/^\d+$/.test(value)) return parseInt(value, 10);
-    if (/^\d+\.\d+$/.test(value)) return parseFloat(value);
-    
-    // Array (inline)
-    if (value.startsWith("[") && value.endsWith("]")) {
-      return value.slice(1, -1).split(",").map(v => this.parseValue(v.trim()));
-    }
-    
-    return value;
-  }
-
-  /**
-   * Compile rule patterns for efficient matching
-   */
-  static compileRule(rule) {
-    const compiled = {
-      filePattern: null,
-      codePattern: null,
-      excludePatterns: [],
-      astQuery: null
-    };
-
-    // Compile file glob
-    if (rule.match.file) {
-      compiled.filePattern = this.globToRegex(rule.match.file);
-    }
-
-    // Compile code pattern
-    if (rule.match.pattern) {
-      try {
-        compiled.codePattern = new RegExp(rule.match.pattern, "gm");
-      } catch {
-        throw new Error(`Invalid regex pattern: ${rule.match.pattern}`);
-      }
-    }
-
-    // Compile exclude patterns
-    for (const exclude of rule.exclude) {
-      compiled.excludePatterns.push(this.globToRegex(exclude));
-    }
-
-    // Parse AST query (simplified)
-    if (rule.match.ast) {
-      compiled.astQuery = this.parseAstQuery(rule.match.ast);
-    }
-
-    return compiled;
-  }
-
-  /**
-   * Convert glob pattern to regex
-   */
-  static globToRegex(glob) {
-    const regex = glob
-      .replace(/[.+^${}()|[\]\\]/g, "\\$&")  // Escape special chars
-      .replace(/\*\*/g, "{{GLOBSTAR}}")      // Protect **
-      .replace(/\*/g, "[^/]*")               // * matches anything except /
-      .replace(/\{\{GLOBSTAR\}\}/g, ".*")    // ** matches everything
-      .replace(/\?/g, ".");                  // ? matches single char
-    
-    return new RegExp(`^${regex}$`);
-  }
-
-  /**
-   * Parse AST query (simplified CSS-like selector)
-   */
-  static parseAstQuery(query) {
-    // Simple AST query format: NodeType[attribute=value]
-    // Example: CallExpression[callee.name="console"]
-    
-    const match = query.match(/^(\w+)(?:\[([^\]]+)\])?$/);
-    if (!match) {
-      throw new Error(`Invalid AST query: ${query}`);
-    }
-
-    return {
-      nodeType: match[1],
-      condition: match[2] ? this.parseAstCondition(match[2]) : null
-    };
-  }
-
-  /**
-   * Parse AST condition
-   */
-  static parseAstCondition(condition) {
-    const match = condition.match(/^([\w.]+)\s*(=|!=|~=)\s*"([^"]+)"$/);
-    if (!match) {
-      throw new Error(`Invalid AST condition: ${condition}`);
-    }
-
-    return {
-      path: match[1],
-      operator: match[2],
-      value: match[3]
-    };
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// RULE EXECUTOR
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class RuleExecutor {
-  constructor(rule) {
-    this.rule = rule;
-    this.compiled = rule._compiled;
-  }
-
-  /**
-   * Execute rule against a file
-   */
-  execute(fileContext) {
-    const { filePath, content, ast, framework, language } = fileContext;
-    const findings = [];
-
-    // Check file pattern
-    if (this.compiled.filePattern && !this.compiled.filePattern.test(filePath)) {
-      return findings; // File doesn't match
-    }
-
-    // Check excludes
-    for (const excludePattern of this.compiled.excludePatterns) {
-      if (excludePattern.test(filePath)) {
-        return findings; // File is excluded
-      }
-    }
-
-    // Check context conditions
-    if (!this.checkContext(fileContext)) {
-      return findings;
-    }
-
-    // Execute pattern match
-    if (this.compiled.codePattern) {
-      const matches = this.findPatternMatches(content);
-      for (const match of matches) {
-        findings.push(this.createFinding(match, fileContext));
-      }
-    }
-
-    // Execute AST match
-    if (this.compiled.astQuery && ast) {
-      const matches = this.findAstMatches(ast);
-      for (const match of matches) {
-        findings.push(this.createFinding(match, fileContext));
-      }
-    }
-
-    // Execute content match
-    if (this.rule.match.content) {
-      if (content.includes(this.rule.match.content)) {
-        const index = content.indexOf(this.rule.match.content);
-        const line = content.substring(0, index).split("\n").length;
-        findings.push(this.createFinding({
-          match: this.rule.match.content,
-          line,
-          column: 0
-        }, fileContext));
-      }
-    }
-
-    // Execute import match
-    if (this.rule.match.import) {
-      const importMatches = this.findImportMatches(content);
-      for (const match of importMatches) {
-        findings.push(this.createFinding(match, fileContext));
-      }
-    }
-
-    // Execute call match
-    if (this.rule.match.call) {
-      const callMatches = this.findCallMatches(content);
-      for (const match of callMatches) {
-        findings.push(this.createFinding(match, fileContext));
-      }
-    }
-
-    return findings;
-  }
-
-  /**
-   * Check context conditions
-   */
-  checkContext(fileContext) {
-    const ctx = this.rule.context;
-    
-    if (ctx.framework && ctx.framework.length > 0) {
-      if (!ctx.framework.includes(fileContext.framework)) {
-        return false;
-      }
-    }
-
-    if (ctx.language && ctx.language.length > 0) {
-      if (!ctx.language.includes(fileContext.language)) {
-        return false;
-      }
-    }
-
-    if (ctx.env) {
-      const isProduction = process.env.NODE_ENV === "production";
-      if (ctx.env === "production" && !isProduction) return false;
-      if (ctx.env === "development" && isProduction) return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Find pattern matches in content
-   */
-  findPatternMatches(content) {
-    const matches = [];
-    const lines = content.split("\n");
-    
-    let match;
-    const regex = new RegExp(this.compiled.codePattern.source, "gm");
-    
-    while ((match = regex.exec(content)) !== null) {
-      const index = match.index;
-      const beforeMatch = content.substring(0, index);
-      const line = beforeMatch.split("\n").length;
-      const lastNewline = beforeMatch.lastIndexOf("\n");
-      const column = index - lastNewline - 1;
-
-      matches.push({
-        match: match[0],
-        groups: match.slice(1),
-        line,
-        column,
-        lineContent: lines[line - 1]
-      });
-    }
-
-    return matches;
-  }
-
-  /**
-   * Find AST matches
-   */
-  findAstMatches(ast) {
-    const matches = [];
-    const query = this.compiled.astQuery;
-
-    const walk = (node, parent = null) => {
-      if (!node || typeof node !== "object") return;
-
-      if (node.type === query.nodeType) {
-        if (!query.condition || this.checkAstCondition(node, query.condition)) {
-          matches.push({
-            node,
-            match: node.type,
-            line: node.loc?.start?.line || 0,
-            column: node.loc?.start?.column || 0
-          });
-        }
-      }
-
-      // Walk children
-      for (const key of Object.keys(node)) {
-        const child = node[key];
-        if (Array.isArray(child)) {
-          for (const item of child) {
-            walk(item, node);
-          }
-        } else if (child && typeof child === "object" && child.type) {
-          walk(child, node);
-        }
-      }
-    };
-
-    walk(ast);
-    return matches;
-  }
-
-  /**
-   * Check AST condition
-   */
-  checkAstCondition(node, condition) {
-    const value = this.getNestedValue(node, condition.path);
-    
-    switch (condition.operator) {
-      case "=":
-        return value === condition.value;
-      case "!=":
-        return value !== condition.value;
-      case "~=":
-        return new RegExp(condition.value).test(value);
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * Get nested value from object using dot notation
-   */
-  getNestedValue(obj, path) {
-    const parts = path.split(".");
-    let current = obj;
-    
-    for (const part of parts) {
-      if (current === null || current === undefined) return undefined;
-      current = current[part];
-    }
-    
-    return current;
-  }
-
-  /**
-   * Find import matches
-   */
-  findImportMatches(content) {
-    const matches = [];
-    const importPattern = this.rule.match.import;
-    const regex = new RegExp(
-      `import\\s+(?:{[^}]*}|[\\w*]+)\\s+from\\s+['"]${importPattern}['"]`,
-      "gm"
-    );
-
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      const line = content.substring(0, match.index).split("\n").length;
-      matches.push({
-        match: match[0],
-        line,
-        column: 0
-      });
-    }
-
-    return matches;
-  }
-
-  /**
-   * Find function call matches
-   */
-  findCallMatches(content) {
-    const matches = [];
-    const callPattern = this.rule.match.call;
-    const regex = new RegExp(`\\b${callPattern}\\s*\\(`, "gm");
-
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      const line = content.substring(0, match.index).split("\n").length;
-      matches.push({
-        match: match[0],
-        line,
-        column: 0
-      });
-    }
-
-    return matches;
-  }
-
-  /**
-   * Create a finding from a match
-   */
-  createFinding(match, fileContext) {
-    return {
-      rule: this.rule.name,
-      type: this.rule.name,
-      severity: this.rule.severity,
-      message: this.rule.description,
-      file: fileContext.filePath,
-      line: match.line,
-      column: match.column,
-      match: match.match,
-      lineContent: match.lineContent,
-      fix: this.rule.fix.suggestion ? {
-        suggestion: this.rule.fix.suggestion,
-        autofix: this.rule.fix.autofix,
-        dangerous: this.rule.fix.dangerous
-      } : null,
-      meta: {
-        ruleAuthor: this.rule.meta.author,
-        ruleVersion: this.rule.meta.version,
-        ruleDocs: this.rule.meta.docs
-      }
-    };
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// CUSTOM RULE ENGINE
-// ═══════════════════════════════════════════════════════════════════════════════
-
-class CustomRuleEngine {
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.rulesPath = options.rulesPath || 
-      path.join(this.projectRoot, ".vibecheck", "rules");
-    this.marketplacePath = options.marketplacePath ||
-      path.join(process.env.HOME || process.env.USERPROFILE, ".vibecheck", "marketplace-rules");
-    this.rules = new Map();
-    this.executors = new Map();
-  }
-
-  /**
-   * Load all rules
-   */
-  async loadRules() {
-    // Load project rules
-    await this.loadRulesFromDirectory(this.rulesPath, "project");
-    
-    // Load marketplace rules
-    await this.loadRulesFromDirectory(this.marketplacePath, "marketplace");
-
-    return {
-      loaded: this.rules.size,
-      rules: Array.from(this.rules.keys())
-    };
-  }
-
-  /**
-   * Load rules from a directory
-   */
-  async loadRulesFromDirectory(dir, source) {
-    if (!fs.existsSync(dir)) return;
-
-    const files = fs.readdirSync(dir);
-    
-    for (const file of files) {
-      if (!file.endsWith(".json") && !file.endsWith(".yaml") && !file.endsWith(".yml")) {
-        continue;
-      }
-
-      const filePath = path.join(dir, file);
-      
-      try {
-        const content = fs.readFileSync(filePath, "utf8");
-        let ruleData;
-        
-        if (file.endsWith(".json")) {
-          ruleData = JSON.parse(content);
-        } else {
-          // For YAML, use DSL parser
-          ruleData = RuleParser.parseDSL(content);
-        }
-
-        // Support single rule or array of rules
-        const rulesArray = Array.isArray(ruleData) ? ruleData : [ruleData];
-        
-        for (const ruleDef of rulesArray) {
-          const rule = RuleParser.parse(ruleDef);
-          rule._source = source;
-          rule._file = filePath;
-          
-          this.rules.set(rule.name, rule);
-          this.executors.set(rule.name, new RuleExecutor(rule));
-        }
-      } catch (error) {
-        console.error(`Failed to load rule from ${filePath}: ${error.message}`);
-      }
-    }
-  }
-
-  /**
-   * Add a rule programmatically
-   */
-  addRule(ruleDefinition) {
-    const rule = RuleParser.parse(ruleDefinition);
-    rule._source = "programmatic";
-    
-    this.rules.set(rule.name, rule);
-    this.executors.set(rule.name, new RuleExecutor(rule));
-    
-    return rule;
-  }
-
-  /**
-   * Execute all rules against a file
-   */
-  executeRules(fileContext) {
-    const findings = [];
-
-    for (const executor of this.executors.values()) {
-      const ruleFindings = executor.execute(fileContext);
-      findings.push(...ruleFindings);
-    }
-
-    return findings;
-  }
-
-  /**
-   * Execute specific rules
-   */
-  executeSpecificRules(fileContext, ruleNames) {
-    const findings = [];
-
-    for (const name of ruleNames) {
-      const executor = this.executors.get(name);
-      if (executor) {
-        const ruleFindings = executor.execute(fileContext);
-        findings.push(...ruleFindings);
-      }
-    }
-
-    return findings;
-  }
-
-  /**
-   * Save a rule to project
-   */
-  saveRule(rule, fileName = null) {
-    if (!fs.existsSync(this.rulesPath)) {
-      fs.mkdirSync(this.rulesPath, { recursive: true });
-    }
-
-    const name = fileName || `${rule.name}.json`;
-    const filePath = path.join(this.rulesPath, name);
-    
-    // Remove internal properties
-    const ruleToSave = { ...rule };
-    delete ruleToSave._compiled;
-    delete ruleToSave._source;
-    delete ruleToSave._file;
-    
-    fs.writeFileSync(filePath, JSON.stringify(ruleToSave, null, 2), "utf8");
-    
-    return filePath;
-  }
-
-  /**
-   * Create rule from template
-   */
-  createFromTemplate(template, options = {}) {
-    const templates = {
-      "no-pattern": {
-        name: options.name || "custom-pattern-rule",
-        description: options.description || "Custom pattern detection",
-        severity: options.severity || "WARN",
-        match: {
-          file: options.file || "**/*.{ts,tsx,js,jsx}",
-          pattern: options.pattern || "TODO"
-        },
-        exclude: options.exclude || ["**/*.test.*", "**/__tests__/**"],
-        fix: {
-          suggestion: options.suggestion || "Address this pattern"
-        }
-      },
-      "no-import": {
-        name: options.name || "custom-import-rule",
-        description: options.description || "Disallow specific import",
-        severity: options.severity || "WARN",
-        match: {
-          file: "**/*.{ts,tsx,js,jsx}",
-          import: options.import || "lodash"
-        },
-        fix: {
-          suggestion: options.suggestion || "Use native alternatives"
-        }
-      },
-      "no-call": {
-        name: options.name || "custom-call-rule",
-        description: options.description || "Disallow specific function call",
-        severity: options.severity || "WARN",
-        match: {
-          file: "**/*.{ts,tsx,js,jsx}",
-          call: options.call || "eval"
-        },
-        fix: {
-          suggestion: options.suggestion || "Avoid this function"
-        }
-      },
-      "framework-specific": {
-        name: options.name || "framework-rule",
-        description: options.description || "Framework-specific rule",
-        severity: options.severity || "WARN",
-        match: {
-          file: options.file || "**/*.{ts,tsx}",
-          pattern: options.pattern || ""
-        },
-        context: {
-          framework: options.framework ? [options.framework] : ["react"]
-        },
-        fix: {
-          suggestion: options.suggestion || "Follow framework best practices"
-        }
-      }
-    };
-
-    const templateRule = templates[template];
-    if (!templateRule) {
-      throw new Error(`Unknown template: ${template}`);
-    }
-
-    return RuleParser.parse(templateRule);
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // MARKETPLACE
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * Publish rule to marketplace (placeholder)
-   */
-  async publishRule(ruleName) {
-    const rule = this.rules.get(ruleName);
-    if (!rule) {
-      throw new Error(`Rule not found: ${ruleName}`);
-    }
-
-    // Generate unique ID
-    const ruleId = crypto.randomBytes(8).toString("hex");
-    
-    // This would upload to marketplace API
-    const published = {
-      id: ruleId,
-      name: rule.name,
-      description: rule.description,
-      author: rule.meta?.author || "anonymous",
-      version: rule.meta?.version || "1.0.0",
-      downloads: 0,
-      rating: 0,
-      publishedAt: new Date().toISOString()
-    };
-
-    return published;
-  }
-
-  /**
-   * Install rule from marketplace (placeholder)
-   */
-  async installRule(ruleId) {
-    if (!fs.existsSync(this.marketplacePath)) {
-      fs.mkdirSync(this.marketplacePath, { recursive: true });
-    }
-
-    // This would fetch from marketplace API
-    // For now, return placeholder
-    return {
-      installed: true,
-      ruleId,
-      path: this.marketplacePath
-    };
-  }
-
-  /**
-   * Search marketplace rules (placeholder)
-   */
-  async searchMarketplace(query) {
-    // This would search marketplace API
-    return {
-      query,
-      results: [],
-      total: 0
-    };
-  }
-
-  /**
-   * Get popular marketplace rules (placeholder)
-   */
-  async getPopularRules(limit = 10) {
-    // This would fetch from marketplace API
-    return {
-      rules: [],
-      total: 0
-    };
-  }
-
-  // ═══════════════════════════════════════════════════════════════════════════
-  // UTILITIES
-  // ═══════════════════════════════════════════════════════════════════════════
-
-  /**
-   * List all loaded rules
-   */
-  listRules() {
-    const rules = [];
-    
-    for (const [name, rule] of this.rules) {
-      rules.push({
-        name,
-        description: rule.description,
-        severity: rule.severity,
-        source: rule._source,
-        file: rule._file
-      });
-    }
-    
-    return rules;
-  }
-
-  /**
-   * Get rule by name
-   */
-  getRule(name) {
-    return this.rules.get(name);
-  }
-
-  /**
-   * Remove rule
-   */
-  removeRule(name) {
-    const rule = this.rules.get(name);
-    
-    if (rule && rule._file && fs.existsSync(rule._file)) {
-      fs.unlinkSync(rule._file);
-    }
-    
-    this.rules.delete(name);
-    this.executors.delete(name);
-    
-    return true;
-  }
-
-  /**
-   * Validate rule definition
-   */
-  validateRule(ruleDefinition) {
-    const errors = [];
-    
-    try {
-      RuleParser.parse(ruleDefinition);
-    } catch (error) {
-      errors.push(error.message);
-    }
-    
-    return {
-      valid: errors.length === 0,
-      errors
-    };
-  }
-
-  /**
-   * Export rules for sharing
-   */
-  exportRules(ruleNames = null) {
-    const toExport = ruleNames 
-      ? ruleNames.map(n => this.rules.get(n)).filter(Boolean)
-      : Array.from(this.rules.values());
-
-    return toExport.map(rule => {
-      const exportRule = { ...rule };
-      delete exportRule._compiled;
-      delete exportRule._source;
-      delete exportRule._file;
-      return exportRule;
-    });
-  }
-
-  /**
-   * Import rules from export
-   */
-  importRules(rulesData) {
-    const imported = [];
-    
-    for (const ruleData of rulesData) {
-      try {
-        const rule = RuleParser.parse(ruleData);
-        this.rules.set(rule.name, rule);
-        this.executors.set(rule.name, new RuleExecutor(rule));
-        imported.push(rule.name);
-      } catch (error) {
-        console.error(`Failed to import rule: ${error.message}`);
-      }
-    }
-    
-    return imported;
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════════════════════
-// EXPORTS
-// ═══════════════════════════════════════════════════════════════════════════════
-
-module.exports = {
-  CustomRuleEngine,
-  RuleParser,
-  RuleExecutor,
-  RULE_SCHEMA
-};