renderpilot 1.0.0

package/src/rules/implementations/R007_MemoCandidate.js

@@ -0,0 +1,87 @@
+/**
+ * @file rules/implementations/R007_MemoCandidate.js
+ */
+
+'use strict';
+
+const { AbstractRule } = require('../base/AbstractRule');
+const { ComponentDetector } = require('../../parser/ComponentDetector');
+const traverse = require('@babel/traverse').default;
+const t = require('@babel/types');
+
+class R007_MemoCandidate extends AbstractRule {
+  constructor() {
+    super({
+      id: 'R007',
+      name: 'React.memo Candidate',
+      description: 'Detects pure components (no state, no effects, only props) that might benefit from React.memo.',
+      severity: 'info',
+      category: 'rendering',
+    });
+  }
+
+  detect(context) {
+    const violations = [];
+    const components = ComponentDetector.extract(context.ast);
+
+    for (const comp of components) {
+      let hasHooks = false;
+      
+      // Traverse inside the component to look for hooks
+      comp.path.traverse({
+        CallExpression(innerPath) {
+          if (t.isIdentifier(innerPath.node.callee)) {
+            if (innerPath.node.callee.name.startsWith('use')) {
+              hasHooks = true;
+              innerPath.stop();
+            }
+          } else if (t.isMemberExpression(innerPath.node.callee) && t.isIdentifier(innerPath.node.callee.property)) {
+             if (innerPath.node.callee.property.name.startsWith('use')) {
+               hasHooks = true;
+               innerPath.stop();
+             }
+          }
+        }
+      });
+
+      if (!hasHooks) {
+        // Pure component!
+        // Does it use React.memo already? We can check the parent of the component node.
+        let isMemoized = false;
+        const parentNode = comp.path.parent;
+        
+        if (t.isCallExpression(parentNode) && t.isIdentifier(parentNode.callee, {name: 'memo'})) {
+           isMemoized = true;
+        } else if (t.isCallExpression(parentNode) && t.isMemberExpression(parentNode.callee) && t.isIdentifier(parentNode.callee.property, {name: 'memo'})) {
+           isMemoized = true;
+        } else if (t.isVariableDeclarator(parentNode) && t.isCallExpression(parentNode.init) && 
+                  (t.isIdentifier(parentNode.init.callee, {name: 'memo'}) || 
+                   (t.isMemberExpression(parentNode.init.callee) && t.isIdentifier(parentNode.init.callee.property, {name: 'memo'})))) {
+           isMemoized = true;
+        }
+
+        if (!isMemoized) {
+          // Check if the component actually accepts props
+          const hasProps = comp.path.node.params && comp.path.node.params.length > 0;
+          
+          if (hasProps) {
+            violations.push(
+              this.createViolation({
+                filePath: context.filePath,
+                line: comp.startLine,
+                column: 0,
+                message: `This component appears to be pure and receives props.`,
+                suggestion: `React.memo may reduce unnecessary re-renders if parent renders frequently.`,
+                componentName: comp.name,
+              })
+            );
+          }
+        }
+      }
+    }
+
+    return violations;
+  }
+}
+
+module.exports = { R007_MemoCandidate };

package/src/rules/implementations/R008_NestedComponent.js

@@ -0,0 +1,65 @@
+/**
+ * @file rules/implementations/R008_NestedComponent.js
+ */
+
+'use strict';
+
+const { AbstractRule } = require('../base/AbstractRule');
+const { ComponentDetector } = require('../../parser/ComponentDetector');
+const { getCodeSnippet } = require('../../parser/ASTUtils');
+const t = require('@babel/types');
+
+class R008_NestedComponent extends AbstractRule {
+  constructor() {
+    super({
+      id: 'R008',
+      name: 'Nested Component Declarations',
+      description: 'Detects components defined inside other components, which forces unmount/remount on every render.',
+      severity: 'critical',
+      category: 'architecture',
+    });
+  }
+
+  detect(context) {
+    const violations = [];
+    const components = ComponentDetector.extract(context.ast);
+
+    // Build a map of components by their path for easy lookup
+    const compPaths = new Set(components.map(c => c.path));
+
+    for (const comp of components) {
+      // Find components whose parent path is ALSO a component
+      let current = comp.path.parentPath;
+      let isNested = false;
+      let parentCompName = '';
+
+      while (current) {
+        if (compPaths.has(current)) {
+           isNested = true;
+           const parentComp = components.find(c => c.path === current);
+           if (parentComp) parentCompName = parentComp.name;
+           break;
+        }
+        current = current.parentPath;
+      }
+
+      if (isNested) {
+        violations.push(
+          this.createViolation({
+            filePath: context.filePath,
+            line: comp.startLine,
+            column: 0,
+            message: `Component "${comp.name}" is declared inside "${parentCompName}".`,
+            suggestion: `Move "${comp.name}" outside of "${parentCompName}". Nested declarations cause React to destroy and recreate the DOM on every render.`,
+            codeSnippet: getCodeSnippet(context.lines, comp.startLine),
+            componentName: comp.name,
+          })
+        );
+      }
+    }
+
+    return violations;
+  }
+}
+
+module.exports = { R008_NestedComponent };

package/src/rules/implementations/R009_UnusedState.js

@@ -0,0 +1,62 @@
+/**
+ * @file rules/implementations/R009_UnusedState.js
+ */
+
+'use strict';
+
+const { AbstractRule } = require('../base/AbstractRule');
+const { getCodeSnippet } = require('../../parser/ASTUtils');
+const traverse = require('@babel/traverse').default;
+const t = require('@babel/types');
+
+class R009_UnusedState extends AbstractRule {
+  constructor() {
+    super({
+      id: 'R009',
+      name: 'Unused React State',
+      description: 'Detects useState variables that are never referenced.',
+      severity: 'warning',
+      category: 'maintainability',
+    });
+  }
+
+  detect(context) {
+    const violations = [];
+
+    traverse(context.ast, {
+      VariableDeclarator: (path) => {
+        if (
+          t.isCallExpression(path.node.init) &&
+          (t.isIdentifier(path.node.init.callee, { name: 'useState' }) || 
+           (t.isMemberExpression(path.node.init.callee) && t.isIdentifier(path.node.init.callee.property, { name: 'useState' }))) &&
+          t.isArrayPattern(path.node.id) &&
+          path.node.id.elements.length > 0
+        ) {
+          const stateVar = path.node.id.elements[0];
+          
+          if (t.isIdentifier(stateVar)) {
+            const name = stateVar.name;
+            const binding = path.scope.getBinding(name);
+            
+            if (binding && !binding.referenced) {
+               violations.push(
+                this.createViolation({
+                  filePath: context.filePath,
+                  line: path.node.loc ? path.node.loc.start.line : 0,
+                  column: path.node.loc ? path.node.loc.start.column : 0,
+                  message: `State variable "${name}" is never used.`,
+                  suggestion: 'Remove unused state to improve maintainability and avoid confusion.',
+                  codeSnippet: getCodeSnippet(context.lines, path.node.loc ? path.node.loc.start.line : 0),
+                })
+              );
+            }
+          }
+        }
+      }
+    });
+
+    return violations;
+  }
+}
+
+module.exports = { R009_UnusedState };

package/src/rules/index.js

@@ -0,0 +1,37 @@
+/**
+ * @file rules/index.js
+ * @description
+ * Bootstraps the Rule Registry by loading and registering all built-in rules.
+ */
+
+'use strict';
+
+const { ruleRegistry } = require('./registry/RuleRegistry');
+const { RuleEngine } = require('./engine/RuleEngine');
+
+// Import all rules
+const { R001_MissingKeyProp } = require('./implementations/R001_MissingKeyProp');
+const { R002_InfiniteUseEffect } = require('./implementations/R002_InfiniteUseEffect');
+const { R003_IncorrectDepsArray } = require('./implementations/R003_IncorrectDepsArray');
+const { R004_LargeComponent } = require('./implementations/R004_LargeComponent');
+const { R005_InlineCallback } = require('./implementations/R005_InlineCallback');
+const { R006_HeavyRenderCalc } = require('./implementations/R006_HeavyRenderCalc');
+const { R007_MemoCandidate } = require('./implementations/R007_MemoCandidate');
+const { R008_NestedComponent } = require('./implementations/R008_NestedComponent');
+const { R009_UnusedState } = require('./implementations/R009_UnusedState');
+
+// Register them
+ruleRegistry.register(new R001_MissingKeyProp());
+ruleRegistry.register(new R002_InfiniteUseEffect());
+ruleRegistry.register(new R003_IncorrectDepsArray());
+ruleRegistry.register(new R004_LargeComponent());
+ruleRegistry.register(new R005_InlineCallback());
+ruleRegistry.register(new R006_HeavyRenderCalc());
+ruleRegistry.register(new R007_MemoCandidate());
+ruleRegistry.register(new R008_NestedComponent());
+ruleRegistry.register(new R009_UnusedState());
+
+module.exports = {
+  ruleRegistry,
+  RuleEngine,
+};

package/src/rules/registry/RuleRegistry.js

@@ -0,0 +1,67 @@
+/**
+ * @file rules/registry/RuleRegistry.js
+ * @description
+ * Manages the registration and lifecycle of all analysis rules.
+ * Provides lookup capabilities and handles enable/disable filtering.
+ */
+
+'use strict';
+
+class RuleRegistry {
+  constructor() {
+    /** @type {Map<string, import('../../base/AbstractRule').AbstractRule>} */
+    this.rules = new Map();
+  }
+
+  /**
+   * Register a new rule instance.
+   * @param {import('../../base/AbstractRule').AbstractRule} ruleInstance
+   */
+  register(ruleInstance) {
+    if (this.rules.has(ruleInstance.id)) {
+      throw new Error(`Rule with ID ${ruleInstance.id} is already registered.`);
+    }
+    this.rules.set(ruleInstance.id, ruleInstance);
+  }
+
+  /**
+   * Get all registered rules.
+   * @returns {import('../../base/AbstractRule').AbstractRule[]}
+   */
+  getAllRules() {
+    return Array.from(this.rules.values());
+  }
+
+  /**
+   * Get rules that should be active for a given configuration.
+   * Handles enable-lists and disable-lists.
+   * @param {import('../../../types').ResolvedConfig} config
+   * @returns {import('../../base/AbstractRule').AbstractRule[]}
+   */
+  getActiveRules(config) {
+    return this.getAllRules().filter((rule) => {
+      // If rule is explicitly disabled, skip it
+      if (config.disabledRules.has(rule.id)) {
+        return false;
+      }
+      // If an allowlist is provided, only include rules in the allowlist
+      if (config.enabledRules !== null && !config.enabledRules.has(rule.id)) {
+        return false;
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Get a specific rule by ID.
+   * @param {string} id
+   * @returns {import('../../base/AbstractRule').AbstractRule | undefined}
+   */
+  getRule(id) {
+    return this.rules.get(id);
+  }
+}
+
+// Export a singleton instance
+const ruleRegistry = new RuleRegistry();
+module.exports = { ruleRegistry, RuleRegistry };

package/src/scanner/FileScanner.js

@@ -0,0 +1,42 @@
+/**
+ * @file scanner/FileScanner.js
+ * @description
+ * Discovers React source files (.js, .jsx, .ts, .tsx) in the given directory.
+ */
+
+'use strict';
+
+const fg = require('fast-glob');
+const path = require('path');
+
+class FileScanner {
+  /**
+   * Find all React source files in the project.
+   * @param {string} rootDir
+   * @param {import('../types').ResolvedConfig} config
+   * @returns {Promise<string[]>} List of absolute file paths
+   */
+  static async discoverFiles(rootDir, config) {
+    // Build ignore patterns
+    const ignore = config.ignoreDirs.map(dir => `**/${dir}/**`);
+    
+    // We only care about JS/TS/JSX/TSX files
+    const patterns = [
+      '**/*.js',
+      '**/*.jsx',
+      '**/*.ts',
+      '**/*.tsx',
+    ];
+
+    const files = await fg(patterns, {
+      cwd: rootDir,
+      ignore,
+      absolute: true,
+      dot: false,
+    });
+
+    return files;
+  }
+}
+
+module.exports = { FileScanner };

package/src/scanner/ProjectScanner.js

@@ -0,0 +1,116 @@
+/**
+ * @file scanner/ProjectScanner.js
+ * @description
+ * Orchestrates the full project scan: discovers files, parses them,
+ * runs the rule engine, and collects the final results.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { FileScanner } = require('./FileScanner');
+const { parseFile } = require('../parser/BabelParser');
+const { RuleEngine } = require('../rules/engine/RuleEngine');
+const { ComponentDetector } = require('../parser/ComponentDetector');
+
+class ProjectScanner {
+  /**
+   * Run a full project scan.
+   * @param {string} rootDir
+   * @param {import('../types').ResolvedConfig} config
+   * @returns {Promise<import('../types').ScanResult>}
+   */
+  static async scan(rootDir, config) {
+    const startedAt = new Date().toISOString();
+    const startTime = Date.now();
+
+    const filePaths = await FileScanner.discoverFiles(rootDir, config);
+    
+    /** @type {import('../types').FileAnalysisResult[]} */
+    const files = [];
+    
+    const allViolations = [];
+    let parseErrors = 0;
+
+    for (const filePath of filePaths) {
+      const fileStartTime = Date.now();
+      const relativePath = path.relative(rootDir, filePath);
+      const source = fs.readFileSync(filePath, 'utf-8');
+      const lines = source.split(/\r?\n/);
+
+      const { ast, error } = parseFile(filePath, source);
+
+      if (error || !ast) {
+        parseErrors++;
+        files.push({
+          filePath,
+          relativePath,
+          violations: [],
+          analysisDurationMs: Date.now() - fileStartTime,
+          parsed: false,
+          parseError: error ? error.message : 'Unknown parse error',
+          lineCount: lines.length,
+          componentNames: [],
+        });
+        continue;
+      }
+
+      // We only care about files that actually have components for some rules,
+      // but we run all rules and let them decide. We extract component names just for the report.
+      const components = ComponentDetector.extract(ast);
+      const componentNames = components.map(c => c.name);
+
+      const context = {
+        ast,
+        filePath,
+        fileContent: source,
+        lines,
+        config,
+      };
+
+      const violations = RuleEngine.run(context);
+      allViolations.push(...violations);
+
+      files.push({
+        filePath,
+        relativePath,
+        violations,
+        analysisDurationMs: Date.now() - fileStartTime,
+        parsed: true,
+        lineCount: lines.length,
+        componentNames,
+      });
+    }
+
+    const durationMs = Date.now() - startTime;
+
+    // Aggregate stats
+    const violationsBySeverity = { critical: 0, warning: 0, info: 0 };
+    const violationsByCategory = { rendering: 0, hooks: 0, architecture: 0, maintainability: 0 };
+    const violationsByRule = {};
+
+    for (const v of allViolations) {
+      violationsBySeverity[v.severity] = (violationsBySeverity[v.severity] || 0) + 1;
+      violationsByCategory[v.category] = (violationsByCategory[v.category] || 0) + 1;
+      violationsByRule[v.ruleId] = (violationsByRule[v.ruleId] || 0) + 1;
+    }
+
+    return {
+      scanRoot: rootDir,
+      startedAt,
+      completedAt: new Date().toISOString(),
+      durationMs,
+      files,
+      totalFiles: filePaths.length,
+      parseErrors,
+      allViolations,
+      totalViolations: allViolations.length,
+      violationsBySeverity,
+      violationsByCategory,
+      violationsByRule,
+    };
+  }
+}
+
+module.exports = { ProjectScanner };

package/src/score/CategoryScorer.js

@@ -0,0 +1,53 @@
+/**
+ * @file score/CategoryScorer.js
+ * @description
+ * Calculates the score for an individual category.
+ */
+
+'use strict';
+
+const { SEVERITY_PENALTY, CATEGORY_WEIGHT } = require('./ScoreWeights');
+
+class CategoryScorer {
+  /**
+   * Calculate a grade based on a numeric score.
+   * @param {number} score
+   * @returns {import('../types').Grade}
+   */
+  static getGrade(score) {
+    if (score >= 90) return 'A';
+    if (score >= 75) return 'B';
+    if (score >= 60) return 'C';
+    if (score >= 40) return 'D';
+    return 'F';
+  }
+
+  /**
+   * Calculate the score for a specific category.
+   * @param {import('../types').Category} category
+   * @param {import('../types').RuleViolation[]} violations
+   * @returns {import('../types').CategoryScore}
+   */
+  static scoreCategory(category, violations) {
+    const categoryViolations = violations.filter(v => v.category === category);
+    
+    let penalty = 0;
+    for (const v of categoryViolations) {
+      const base = SEVERITY_PENALTY[v.severity] || 0;
+      const weight = CATEGORY_WEIGHT[category] || 1;
+      penalty += (base * weight);
+    }
+
+    const score = Math.max(0, Math.round(100 - penalty));
+
+    return {
+      category,
+      score,
+      grade: this.getGrade(score),
+      violations: categoryViolations.length,
+      penaltyApplied: penalty,
+    };
+  }
+}
+
+module.exports = { CategoryScorer };

package/src/score/ScoreCalculator.js

@@ -0,0 +1,97 @@
+/**
+ * @file score/ScoreCalculator.js
+ * @description
+ * Calculates the overall performance score and aggregates category scores.
+ */
+
+'use strict';
+
+const { CategoryScorer } = require('./CategoryScorer');
+const { SEVERITY_PENALTY, CATEGORY_WEIGHT } = require('./ScoreWeights');
+
+class ScoreCalculator {
+  /**
+   * Get human-readable label for a score.
+   * @param {number} score
+   * @returns {string}
+   */
+  static getLabel(score) {
+    if (score >= 90) return 'Excellent';
+    if (score >= 75) return 'Good';
+    if (score >= 60) return 'Needs Work';
+    if (score >= 40) return 'Poor';
+    return 'Critical';
+  }
+
+  /**
+   * Get top recommendation based on violations.
+   * @param {import('../types').RuleViolation[]} violations
+   * @returns {string}
+   */
+  static getTopRecommendation(violations) {
+    if (violations.length === 0) return 'Keep up the great work!';
+    
+    const critical = violations.filter(v => v.severity === 'critical');
+    if (critical.length > 0) {
+      return `Fix ${critical.length} critical issues immediately to prevent infinite loops and broken UI.`;
+    }
+
+    const rendering = violations.filter(v => v.category === 'rendering' && v.severity === 'warning');
+    if (rendering.length > 0) {
+       return `Focus on reducing unnecessary rerenders by fixing keys and memoizing heavy calculations.`;
+    }
+
+    return 'Review the warnings to further optimize component performance.';
+  }
+
+  /**
+   * Compute the full performance score.
+   * @param {import('../types').RuleViolation[]} violations
+   * @returns {import('../types').PerformanceScore}
+   */
+  static compute(violations) {
+    let totalPenalty = 0;
+    let criticalPenalty = 0;
+    
+    const penaltyBySeverity = { critical: 0, warning: 0, info: 0 };
+    
+    for (const v of violations) {
+      const base = SEVERITY_PENALTY[v.severity] || 0;
+      const weight = CATEGORY_WEIGHT[v.category] || 1;
+      const penalty = base * weight;
+      
+      totalPenalty += penalty;
+      penaltyBySeverity[v.severity] += penalty;
+      
+      if (v.severity === 'critical') {
+        criticalPenalty += penalty;
+      }
+    }
+
+    const overallScore = Math.max(0, Math.round(100 - totalPenalty));
+    
+    const categories = [
+      CategoryScorer.scoreCategory('rendering', violations),
+      CategoryScorer.scoreCategory('hooks', violations),
+      CategoryScorer.scoreCategory('architecture', violations),
+      CategoryScorer.scoreCategory('maintainability', violations),
+    ];
+
+    const estimatedImprovementOnCriticalFix = Math.min(100 - overallScore, Math.round(criticalPenalty));
+    const estimatedImprovementOnAllFix = Math.min(100 - overallScore, Math.round(totalPenalty));
+
+    return {
+      overall: overallScore,
+      grade: CategoryScorer.getGrade(overallScore),
+      label: this.getLabel(overallScore),
+      categories,
+      totalPenalty,
+      penaltyBySeverity,
+      estimatedImprovementOnCriticalFix,
+      estimatedImprovementOnAllFix,
+      topRecommendation: this.getTopRecommendation(violations),
+    };
+  }
+}
+
+module.exports = { ScoreCalculator };

package/src/score/ScoreWeights.js

@@ -0,0 +1,33 @@
+/**
+ * @file score/ScoreWeights.js
+ * @description
+ * Defines the constant weights and penalties for the scoring algorithm.
+ */
+
+'use strict';
+
+/**
+ * Base penalty applied per violation based on severity.
+ * @type {Record<import('../types').Severity, number>}
+ */
+const SEVERITY_PENALTY = {
+  critical: 15,
+  warning: 5,
+  info: 1,
+};
+
+/**
+ * Multiplier applied to the penalty based on category.
+ * @type {Record<import('../types').Category, number>}
+ */
+const CATEGORY_WEIGHT = {
+  rendering: 1.5,
+  hooks: 1.3,
+  architecture: 1.0,
+  maintainability: 0.7,
+};
+
+module.exports = {
+  SEVERITY_PENALTY,
+  CATEGORY_WEIGHT,
+};