@sun-asterisk/sunlint 1.3.30 → 1.3.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sun-asterisk/sunlint",
-  "version": "1.3.30",
+  "version": "1.3.31",
   "description": "☀️ SunLint - Multi-language static analysis tool for code quality and security | Sun* Engineering Standards",
   "main": "cli.js",
   "bin": {

package/rules/common/C006_function_naming/analyzer.js

@@ -45,11 +45,92 @@ class SmartC006Analyzer {
       // Side effect patterns indicate actions
       ACTION: [/console\./, /fetch\(/, /\.send\(/, /\.post\(/]
     };
+
+    // 📚 COMPREHENSIVE VERB LIST (from C006 rule specification)
+    this.acceptedVerbs = [
+      // Getters/Queries
+      'get', 'fetch', 'retrieve', 'find', 'search', 'query', 'load',
+      // Setters/Modifiers
+      'set', 'update', 'modify', 'change', 'edit', 'alter', 'transform',
+      // Creation
+      'create', 'build', 'make', 'generate', 'construct', 'produce',
+      // Deletion
+      'delete', 'remove', 'destroy', 'clean', 'clear', 'reset',
+      // Validation
+      'validate', 'verify', 'check', 'confirm', 'ensure', 'test', 'compare',
+      // Computation
+      'calculate', 'compute', 'parse', 'format', 'convert',
+      // Communication
+      'send', 'receive', 'transmit', 'broadcast', 'emit', 'publish',
+      // Collections
+      'map', 'filter', 'sort', 'group', 'merge', 'split', 'add', 'append', 'insert',
+      'push', 'pop', 'shift', 'splice', 'unshift', 'slice', 'concat', 'join',
+      // State checks (Boolean)
+      'is', 'has', 'can', 'should', 'will', 'does', 'contains', 'includes', 'exists',
+      // UI actions
+      'show', 'hide', 'display', 'render', 'draw', 'toggle', 'enable', 'disable',
+      'activate', 'deactivate', 'select', 'deselect', 'focus', 'blur',
+      // Lifecycle
+      'connect', 'disconnect', 'open', 'close', 'start', 'stop', 'run', 'refresh',
+      'initialize', 'init', 'setup', 'teardown', 'shutdown', 'restart', 'reload',
+      'restore', 'resume', 'pause', 'suspend',
+      // Event Handling
+      'on', 'trigger', 'fire', 'dispatch', 'invoke', 'call', 'emit', 'handle',
+      // Monitoring
+      'count', 'measure', 'monitor', 'watch', 'track', 'observe', 'log', 'record',
+      // Navigation
+      'navigate', 'redirect', 'route', 'go', 'move', 'scroll',
+      // Data Operations
+      'save', 'store', 'persist', 'cache', 'serialize', 'deserialize',
+      // Detection/Analysis
+      'detect', 'analyze', 'scan', 'inspect', 'evaluate', 'assess',
+      // Computation & Transformation
+      'calculate', 'compute', 'parse', 'format', 'convert',
+      'normalize', 'sanitize', 'encode', 'decode', 'encrypt', 'decrypt',
+      'compress', 'decompress', 'zip', 'unzip', 'tar', 'untar', // ← Add these
+      'stringify', 'objectify',
+      // State Management
+      'apply', 'revert', 'undo', 'redo', 'commit', 'rollback',
+      // Async Operations
+      'await', 'defer', 'debounce', 'throttle', 'delay',
+      // Error Handling
+      'throw', 'catch', 'handle', 'recover', 'retry',
+      // Copying/Cloning
+      'copy', 'clone', 'duplicate', 'replicate',
+      // Comparison
+      'equals', 'match', 'differ', 'compare',
+      // Registration
+      'register', 'unregister', 'subscribe', 'unsubscribe',
+      // Import/Export
+      'import', 'export', 'download', 'upload',
+      // Expansion/Collapse
+      'expand', 'collapse', 'maximize', 'minimize',
+      // Submission
+      'submit', 'cancel', 'abort', 'complete', 'finish',
+      // Preparation
+      'prepare', 'ready', 'preload', 'precache',
+      // Extraction
+      'extract', 'derive', 'obtain', 'acquire',
+      // Replacement
+      'replace', 'swap', 'substitute', 'override',
+      // Binding
+      'bind', 'unbind', 'attach', 'detach',
+      // Notification
+      'notify', 'alert', 'warn', 'inform',
+      // Execution
+      'execute', 'perform', 'process', 'run'
+    ];
+
+    // ⚠️ VAGUE/GENERIC VERBS TO FLAG (should have more specific verbs)
+    this.vagueVerbs = [
+      'do', 'handle', 'manage', 'process', 'execute', 'perform',
+      'something', 'stuff', 'thing', 'work', 'data', 'item'
+    ];
   }
 
   async analyze(files, language, config) {
     const violations = [];
-    
+
     if (config.verbose) {
       console.log(`🔧 [DEBUG] Starting Smart C006 Analysis on ${files.length} files...`);
     }
@@ -69,7 +150,7 @@ class SmartC006Analyzer {
     if (config.verbose) {
       console.log(`🔧 [DEBUG] Smart C006 Analysis complete: ${violations.length} violations found`);
     }
-    
+
     return violations;
   }
 
@@ -80,10 +161,10 @@ class SmartC006Analyzer {
 
     const violations = [];
     const lines = content.split('\n');
-    
+
     // 🏗️ TIER 1: ARCHITECTURAL CONTEXT ANALYSIS
     const architecturalContext = this.analyzeArchitecturalContext(filePath, content);
-    
+
     // Parse TypeScript/JavaScript code
     const sourceFile = ts.createSourceFile(
       filePath,
@@ -102,13 +183,13 @@ class SmartC006Analyzer {
           architecturalContext,
           content
         );
-        
+
         if (analysis.isViolation && analysis.confidence >= this.confidenceThresholds.LOW) {
           const namePosition = sourceFile.getLineAndCharacterOfPosition(node.name.getStart());
           const line = namePosition.line + 1;
           const column = namePosition.character + 1;
           const lineText = lines[line - 1]?.trim() || '';
-          
+
           violations.push({
             ruleId: this.ruleId,
             file: filePath,
@@ -134,13 +215,13 @@ class SmartC006Analyzer {
           architecturalContext,
           content
         );
-        
+
         if (analysis.isViolation && analysis.confidence >= this.confidenceThresholds.LOW) {
           const namePosition = sourceFile.getLineAndCharacterOfPosition(node.name.getStart());
           const line = namePosition.line + 1;
           const column = namePosition.character + 1;
           const lineText = lines[line - 1]?.trim() || '';
-          
+
           violations.push({
             ruleId: this.ruleId,
             file: filePath,
@@ -158,7 +239,7 @@ class SmartC006Analyzer {
       }
 
       // Analyze arrow functions assigned to variables
-      if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name) && 
+      if (ts.isVariableDeclaration(node) && node.name && ts.isIdentifier(node.name) &&
           node.initializer && ts.isArrowFunction(node.initializer)) {
         const analysis = this.smartAnalyzeFunctionName(
           node.name.text,
@@ -167,13 +248,13 @@ class SmartC006Analyzer {
           architecturalContext,
           content
         );
-        
+
         if (analysis.isViolation && analysis.confidence >= this.confidenceThresholds.LOW) {
           const namePosition = sourceFile.getLineAndCharacterOfPosition(node.name.getStart());
           const line = namePosition.line + 1;
           const column = namePosition.character + 1;
           const lineText = lines[line - 1]?.trim() || '';
-          
+
           violations.push({
             ruleId: this.ruleId,
             file: filePath,
@@ -189,7 +270,7 @@ class SmartC006Analyzer {
           });
         }
       }
-      
+
       ts.forEachChild(node, visit);
     };
 
@@ -204,7 +285,7 @@ class SmartC006Analyzer {
   analyzeArchitecturalContext(filePath, content) {
     const fileName = path.basename(filePath, path.extname(filePath)).toLowerCase();
     const fileDir = path.dirname(filePath).toLowerCase();
-    
+
     // Detect architectural layer
     let layer = 'UNKNOWN';
     for (const [layerName, patterns] of Object.entries(this.architecturalLayers)) {
@@ -213,12 +294,12 @@ class SmartC006Analyzer {
         break;
       }
     }
-    
+
     // Analyze imports for additional context
     const imports = this.extractImports(content);
     const isReactComponent = imports.some(imp => imp.includes('react')) || content.includes('JSX.Element');
     const isTestFile = fileName.includes('test') || fileName.includes('spec');
-    
+
     return {
       layer,
       isReactComponent,
@@ -234,83 +315,96 @@ class SmartC006Analyzer {
    */
   analyzeSemanticIntent(functionNode, sourceFile, content) {
     if (!functionNode.body) return 'UNKNOWN';
-    
+
     const functionText = content.substring(
       functionNode.body.getStart(),
       functionNode.body.getEnd()
     );
-    
+
     // Check for different semantic patterns
     for (const [intent, patterns] of Object.entries(this.semanticPatterns)) {
       if (patterns.some(pattern => pattern.test(functionText))) {
         return intent;
       }
     }
-    
+
     return 'UNKNOWN';
   }
 
   /**
-   * 🎯 TIER 3: INTELLIGENT VERB DETECTION
-   * Uses multiple strategies to detect verbs
+   * 🎯 ENHANCED VERB DETECTION - FIXED VERSION
+   * Properly detects verbs including compound verbs
    */
-  isVerbLikeName(functionName) {
-    // Strategy 0: REJECT generic/vague verbs that should be flagged
-    const genericVerbs = [
-      'do', 'handle', 'process', 'manage', 'execute',
-      'something', 'stuff', 'thing', 'work', 'data'
-    ];
-    
-    const isGenericVerb = genericVerbs.some(verb => {
-      const verbPattern = new RegExp(`^${verb}([A-Z].*|$)`, 'i');
-      return verbPattern.test(functionName);
-    });
-    
-    // Reject names starting with generic verbs
-    if (isGenericVerb) return false;
-    
-    // Strategy 1: Known verb prefixes (expanded beyond static list)
-    const verbPrefixes = [
-      'get', 'set', 'is', 'has', 'can', 'should', 'will', 'does',
-      'create', 'build', 'make', 'generate', 'construct', 'produce',
-      'update', 'modify', 'change', 'edit', 'alter', 'transform',
-      'delete', 'remove', 'destroy', 'clean', 'clear', 'reset',
-      'load', 'save', 'fetch', 'retrieve', 'find', 'search', 'query',
-      'validate', 'verify', 'check', 'confirm', 'ensure', 'test',
-      'calculate', 'compute', 'compare', 'parse', 'format', 'convert',
-      'send', 'receive', 'transmit', 'broadcast', 'emit', 'publish',
-      'map', 'filter', 'sort', 'group', 'merge', 'split',
-      'connect', 'disconnect', 'open', 'close', 'start', 'stop', 'run',
-      'show', 'hide', 'display', 'render', 'draw', 'paint', 'animate',
-      'add', 'append', 'insert', 'push', 'pop', 'shift', 'splice',
-      'count', 'measure', 'monitor', 'watch', 'track', 'observe',
-      'refresh', 'restore', 'reload', 'retry', 'resume', 'redirect',
-      'select', 'toggle', 'switch', 'enable', 'disable', 'activate',
-      'expand', 'collapse', 'scroll', 'navigate', 'submit', 'cancel',
-      'on', 'trigger', 'fire', 'dispatch', 'invoke', 'call'
-    ];
-    
-    // Strategy 2: Check if starts with known verb
-    const startsWithVerb = verbPrefixes.some(verb => {
-      const verbPattern = new RegExp(`^${verb}[A-Z]?`, 'i');
-      return verbPattern.test(functionName);
-    });
-    
-    if (startsWithVerb) return true;
-    
-    // Strategy 3: Common verb suffixes that indicate actions
-    const actionSuffixes = ['ize', 'ise', 'fy', 'ate', 'en'];
-    if (actionSuffixes.some(suffix => functionName.endsWith(suffix))) {
-      return true;
+  extractVerbFromName(functionName) {
+    // Convert to lowercase for comparison
+    const lowerName = functionName.toLowerCase();
+
+    // Find the longest matching verb from the accepted verbs list
+    let matchedVerb = null;
+    let maxLength = 0;
+
+    for (const verb of this.acceptedVerbs) {
+      // Check if function name starts with this verb
+      // Must be followed by uppercase letter, end of string, or be exact match
+      const verbPattern = new RegExp(`^${verb}([A-Z].*|$)`);
+
+      if (verbPattern.test(functionName) && verb.length > maxLength) {
+        matchedVerb = verb;
+        maxLength = verb.length;
+      }
     }
-    
-    // Strategy 4: English verb patterns (basic NLP)
-    const verbPatterns = [
-      /^(re|un|pre|de|dis)[A-Z]/, // prefixed verbs: revalidate, unload, preprocess
-      /^[a-z]+ly[A-Z]/, // adverb-verb patterns: quicklyProcess
-    ];
-    
-    return verbPatterns.some(pattern => pattern.test(functionName));
+
+    return matchedVerb;
+  }
+
+  /**
+   * 🎯 CHECK IF NAME FOLLOWS VERB-NOUN PATTERN
+   */
+  isVerbNounPattern(functionName) {
+    // Strategy 1: Extract verb from accepted verbs list
+    const verb = this.extractVerbFromName(functionName);
+
+    if (verb) {
+      // Check if it's a vague verb (should be flagged even if technically a verb)
+      const isVagueVerb = this.vagueVerbs.some(vague => {
+        const vaguePattern = new RegExp(`^${vague}([A-Z].*|$)`, 'i');
+        return vaguePattern.test(functionName);
+      });
+
+      if (isVagueVerb) {
+        return { isValid: false, verb: null, reason: 'vague_verb' };
+      }
+
+      // Valid verb found
+      return { isValid: true, verb, reason: null };
+    }
+
+    // Strategy 2: Check for verb-like patterns (morphology)
+    const verbSuffixes = ['ize', 'ise', 'fy', 'ate', 'en', 'ing', 'ed'];
+    for (const suffix of verbSuffixes) {
+      const suffixPattern = new RegExp(`^[a-z]+${suffix}([A-Z].*|$)`, 'i');
+      if (suffixPattern.test(functionName)) {
+        return { isValid: true, verb: 'morphological', reason: null };
+      }
+    }
+
+    // Strategy 3: Check for verb prefixes (re-, un-, pre-, de-, dis-)
+    const verbPrefixes = ['re', 'un', 'pre', 'de', 'dis', 'over', 'under', 'out', 'up'];
+    for (const prefix of verbPrefixes) {
+      // Must be followed by a known verb or capital letter
+      const prefixPattern = new RegExp(`^${prefix}[A-Z]`, 'i');
+      if (prefixPattern.test(functionName)) {
+        // Check if the part after prefix is a known verb
+        const remainder = functionName.substring(prefix.length);
+        const remainderVerb = this.extractVerbFromName(remainder);
+        if (remainderVerb) {
+          return { isValid: true, verb: `${prefix}${remainderVerb}`, reason: null };
+        }
+      }
+    }
+
+    // No verb pattern found
+    return { isValid: false, verb: null, reason: 'no_verb' };
   }
 
   /**
@@ -323,29 +417,29 @@ class SmartC006Analyzer {
       requiredPatterns: [],
       suggestions: []
     };
-    
+
     // React components have different naming conventions
     if (architecturalContext.isReactComponent) {
       rules.allowedPatterns.push(/^[A-Z][a-zA-Z]*$/); // PascalCase components
       rules.allowedPatterns.push(/^use[A-Z][a-zA-Z]*$/); // React hooks
       rules.allowedPatterns.push(/^handle[A-Z][a-zA-Z]*$/); // Event handlers
     }
-    
+
     // Test files have different patterns
     if (architecturalContext.isTestFile) {
       rules.allowedPatterns.push(/^(test|it|describe|should|expect)[A-Z]?/);
     }
-    
+
     // Data layer functions often have CRUD patterns
     if (architecturalContext.layer === 'DATA') {
-      rules.suggestions.push('Consider CRUD verbs: create, read, update, delete');
+      rules.suggestions.push('Consider CRUD verbs: create, read, update, delete, fetch, save');
     }
-    
+
     // UI layer functions often have interaction verbs
     if (architecturalContext.layer === 'UI') {
-      rules.suggestions.push('Consider UI verbs: show, hide, toggle, render, display');
+      rules.suggestions.push('Consider UI verbs: show, hide, toggle, render, display, handle');
     }
-    
+
     return rules;
   }
 
@@ -358,88 +452,103 @@ class SmartC006Analyzer {
     if (this.isSpecialFunction(functionName, architecturalContext)) {
       return { isViolation: false };
     }
-    
+
     // Get semantic intent
     const semanticIntent = this.analyzeSemanticIntent(functionNode, sourceFile, content);
-    
+
     // Get context-specific rules
     const contextRules = this.getContextSpecificRules(architecturalContext, semanticIntent);
-    
+
     // Check if allowed by context-specific patterns
     if (contextRules.allowedPatterns.some(pattern => pattern.test(functionName))) {
       return { isViolation: false };
     }
-    
+
     // Check if name follows verb-noun pattern
-    const isVerbLike = this.isVerbLikeName(functionName);
-    
-    if (isVerbLike) {
+    const verbCheck = this.isVerbNounPattern(functionName);
+
+    if (verbCheck.isValid) {
       return { isViolation: false };
     }
-    
+
     // 🧮 CONFIDENCE CALCULATION
     let confidence = 0.5; // Base confidence
-    
-    // Boost confidence for clearly generic/vague patterns
-    const vagueFunctionNames = [
-      'doSomething', 'handleStuff', 'processData', 'processInfo',
-      'executeWork', 'manageItems', 'doWork', 'handleData',
-      'something', 'stuff', 'thing', 'data', 'info', 'item'
-    ];
-    
-    if (vagueFunctionNames.some(vague => functionName.toLowerCase().includes(vague.toLowerCase()))) {
-      confidence += 0.4; // Strongly boost confidence for obviously vague names
-    }
-    
-    // Boost confidence for clear noun-only patterns
-    if (/^[a-z]+$/.test(functionName)) {
-      confidence += 0.3; // Simple lowercase nouns: user, data
-    }
-    
-    if (/^[a-z]+[A-Z][a-z]+$/.test(functionName)) {
-      confidence += 0.2; // Simple camelCase nouns: userData, userInfo
+    let violationType = 'no_verb';
+
+    if (verbCheck.reason === 'vague_verb') {
+      violationType = 'vague_verb';
+      confidence = 0.9; // High confidence for vague verbs
+    } else if (verbCheck.reason === 'no_verb') {
+      violationType = 'no_verb';
+
+      // Check for obviously wrong patterns
+      const commonNounPatterns = [
+        /^(user|data|info|item|list|config|settings|options|params|args|props|state|value|result|response|request|error|message|event|callback|handler)([A-Z][a-z]*)*$/i,
+        /^[a-z]+$/, // Simple lowercase words
+        /^[a-z]+[A-Z][a-z]+$/ // Simple camelCase nouns
+      ];
+
+      if (commonNounPatterns.some(pattern => pattern.test(functionName))) {
+        confidence = 0.8; // High confidence for obvious nouns
+      }
+
+      // Boost confidence for clearly generic patterns
+      const vagueFunctionNames = [
+        'something', 'stuff', 'thing', 'data', 'info', 'item',
+        'work', 'task', 'job', 'action', 'operation'
+      ];
+
+      if (vagueFunctionNames.some(vague => functionName.toLowerCase().includes(vague.toLowerCase()))) {
+        confidence = 0.95; // Very high confidence
+      }
     }
-    
-    // Reduce confidence for complex names (might have hidden verbs)
-    if (functionName.length > 15) {
-      confidence -= 0.1;
+
+    // Reduce confidence for complex names (might have hidden patterns)
+    if (functionName.length > 20) {
+      confidence -= 0.15;
     }
-    
+
     // Reduce confidence for utils/helpers (more flexible naming)
     if (architecturalContext.layer === 'UTILS') {
       confidence -= 0.2;
     }
-    
+
     // Reduce confidence for test files
     if (architecturalContext.isTestFile) {
       confidence -= 0.3;
     }
-    
+
     // Cap confidence
     confidence = Math.min(Math.max(confidence, 0.1), 1.0);
-    
+
     // 💬 INTELLIGENT MESSAGING
     const context = {
       layer: architecturalContext.layer,
       intent: semanticIntent,
       isReactComponent: architecturalContext.isReactComponent,
-      isTestFile: architecturalContext.isTestFile
+      isTestFile: architecturalContext.isTestFile,
+      violationType
     };
-    
-    let reason = `Function '${functionName}' should follow verb-noun naming pattern`;
-    let suggestion = this.generateSmartSuggestion(functionName, semanticIntent, architecturalContext);
+
+    let reason = '';
+    let suggestion = '';
+
+    if (violationType === 'vague_verb') {
+      reason = `Function '${functionName}' uses vague verb. Use more specific action verbs (see C006 accepted verbs list)`;
+      suggestion = this.generateSmartSuggestion(functionName, semanticIntent, architecturalContext, true);
+    } else {
+      reason = `Function '${functionName}' must start with a verb (verb-noun pattern required by C006)`;
+      suggestion = this.generateSmartSuggestion(functionName, semanticIntent, architecturalContext, false);
+    }
 
     if (architecturalContext.layer !== 'UNKNOWN') {
       reason += ` (${architecturalContext.layer} layer)`;
     }
 
-    // Add helpful note about accepted verbs
-    reason += `. Accepted verbs: get, set, create, update, delete, validate, check, compare, etc. See: https://coding-standards.sun-asterisk.vn/rules/rule/C006/`;
-    
     return {
       isViolation: true,
       reason,
-      type: 'smart_naming_violation',
+      type: `smart_naming_violation_${violationType}`,
       confidence,
       suggestion,
       context
@@ -449,27 +558,51 @@ class SmartC006Analyzer {
   /**
    * 💡 SMART SUGGESTION GENERATOR
    */
-  generateSmartSuggestion(functionName, semanticIntent, architecturalContext) {
-    const baseNoun = functionName.charAt(0).toUpperCase() + functionName.slice(1);
-    
+  generateSmartSuggestion(functionName, semanticIntent, architecturalContext, isVagueVerb) {
+    // If it's a vague verb, extract the noun part
+    let baseNoun = functionName;
+
+    if (isVagueVerb) {
+      // Try to extract the noun part after the vague verb
+      for (const vagueVerb of this.vagueVerbs) {
+        const pattern = new RegExp(`^${vagueVerb}([A-Z].*)$`, 'i');
+        const match = functionName.match(pattern);
+        if (match) {
+          baseNoun = match[1];
+          break;
+        }
+      }
+    }
+
+    // Ensure first letter is capitalized for camelCase
+    baseNoun = baseNoun.charAt(0).toUpperCase() + baseNoun.slice(1);
+
+    const suggestions = [];
+
     switch (semanticIntent) {
       case 'GETTER':
-        return `get${baseNoun}()`;
+        suggestions.push(`get${baseNoun}()`, `fetch${baseNoun}()`, `retrieve${baseNoun}()`);
+        break;
       case 'SETTER':
-        return `set${baseNoun}()`;
+        suggestions.push(`set${baseNoun}()`, `update${baseNoun}()`, `save${baseNoun}()`);
+        break;
       case 'CHECKER':
-        return `is${baseNoun}() or has${baseNoun}()`;
+        suggestions.push(`is${baseNoun}()`, `has${baseNoun}()`, `can${baseNoun}()`, `should${baseNoun}()`);
+        break;
       case 'ACTION':
-        return `process${baseNoun}() or handle${baseNoun}()`;
+        suggestions.push(`process${baseNoun}()`, `handle${baseNoun}()`, `execute${baseNoun}()`);
+        break;
       default:
         if (architecturalContext.layer === 'DATA') {
-          return `fetch${baseNoun}() or create${baseNoun}()`;
-        }
-        if (architecturalContext.layer === 'UI') {
-          return `render${baseNoun}() or show${baseNoun}()`;
+          suggestions.push(`fetch${baseNoun}()`, `create${baseNoun}()`, `save${baseNoun}()`, `load${baseNoun}()`);
+        } else if (architecturalContext.layer === 'UI') {
+          suggestions.push(`render${baseNoun}()`, `show${baseNoun}()`, `display${baseNoun}()`, `draw${baseNoun}()`);
+        } else {
+          suggestions.push(`get${baseNoun}()`, `set${baseNoun}()`, `process${baseNoun}()`, `handle${baseNoun}()`);
         }
-        return `get${baseNoun}() or process${baseNoun}()`;
     }
+
+    return suggestions.slice(0, 3).join(' or ');
   }
 
   /**
@@ -489,22 +622,22 @@ class SmartC006Analyzer {
     if (specialFunctions.includes(name) || name.startsWith('_') || name.startsWith('$')) {
       return true;
     }
-    
+
     // React component names (PascalCase)
     if (architecturalContext.isReactComponent && /^[A-Z][a-zA-Z]*$/.test(name)) {
       return true;
     }
-    
+
     // React hooks
     if (name.startsWith('use') && /^use[A-Z]/.test(name)) {
       return true;
     }
-    
+
     // Test function names
     if (architecturalContext.isTestFile && /^(test|it|describe|should|expect)/.test(name)) {
       return true;
     }
-    
+
     return false;
   }
 
@@ -515,11 +648,11 @@ class SmartC006Analyzer {
     const importRegex = /import\s+.*?\s+from\s+['"]([^'"]+)['"]/g;
     const imports = [];
     let match;
-    
+
     while ((match = importRegex.exec(content)) !== null) {
       imports.push(match[1]);
     }
-    
+
     return imports;
   }
 

package/rules/common/C067_no_hardcoded_config/symbol-based-analyzer.js

@@ -845,7 +845,8 @@ class C067SymbolBasedAnalyzer {
       /\.config\.(ts|js)$/,
       /\.env$/,
       /\.env\./,
-      /constants\.(ts|js)$/,
+      /constants?\.(ts|js)$/,           // constants.ts, constant.ts
+      /\.constants?\.(ts|js)$/,         // app.constants.ts, common.constant.ts
       /settings\.(ts|js)$/,
       /defaults\.(ts|js)$/,
     ];

package/rules/security/S031_secure_session_cookies/analyzer.js

@@ -1,12 +1,10 @@
 /**
  * S031 Main Analyzer - Set Secure flag for Session Cookies
- * Primary: Symbol-based analysis (when available)
- * Fallback: Regex-based for all other cases
+ * Uses symbol-based analysis only (regex-based removed)
  * Command: node cli.js --rule=S031 --input=examples/rule-test-fixtures/rules/S031_secure_session_cookies --engine=heuristic
  */
 
 const S031SymbolBasedAnalyzer = require("./symbol-based-analyzer.js");
-const S031RegexBasedAnalyzer = require("./regex-based-analyzer.js");
 
 class S031Analyzer {
   constructor(options = {}) {
@@ -26,14 +24,7 @@ class S031Analyzer {
     this.semanticEngine = options.semanticEngine || null;
     this.verbose = options.verbose || false;
 
-    // Configuration
-    this.config = {
-      useSymbolBased: true, // Primary approach
-      fallbackToRegex: true, // Secondary approach
-      regexBasedOnly: false, // Can be set to true for pure mode
-    };
-
-    // Initialize analyzers
+    // Initialize symbol analyzer only
     try {
       this.symbolAnalyzer = new S031SymbolBasedAnalyzer(this.semanticEngine);
       if (process.env.SUNLINT_DEBUG) {
@@ -43,48 +34,39 @@ class S031Analyzer {
       console.error(`🔧 [S031] Error creating symbol analyzer:`, error);
     }
 
-    try {
-      this.regexAnalyzer = new S031RegexBasedAnalyzer(this.semanticEngine);
-      if (process.env.SUNLINT_DEBUG) {
-        console.log(`🔧 [S031] Regex analyzer created successfully`);
-      }
-    } catch (error) {
-      console.error(`🔧 [S031] Error creating regex analyzer:`, error);
+    if (process.env.SUNLINT_DEBUG) {
+      console.log(`🔧 [S031] Constructor completed`);
     }
   }
 
   /**
    * Initialize analyzer with semantic engine
-
    */
-  async initialize(semanticEngine) {
-    this.semanticEngine = semanticEngine;
-
-    if (process.env.SUNLINT_DEBUG) {
-      console.log(`🔧 [S031] Main analyzer initializing...`);
+  async initialize(semanticEngine = null) {
+    if (semanticEngine) {
+      this.semanticEngine = semanticEngine;
     }
+    this.verbose = semanticEngine?.verbose || false;
 
-    // Initialize both analyzers
+    // Initialize symbol analyzer
     if (this.symbolAnalyzer) {
       await this.symbolAnalyzer.initialize?.(semanticEngine);
     }
-    if (this.regexAnalyzer) {
-      await this.regexAnalyzer.initialize?.(semanticEngine);
-    }
 
-    // Clean up if needed
-    if (this.regexAnalyzer) {
-      this.regexAnalyzer.cleanup?.();
+    // Ensure verbose flag is propagated
+    if (this.symbolAnalyzer) {
+      this.symbolAnalyzer.verbose = this.verbose;
     }
 
-    if (process.env.SUNLINT_DEBUG) {
-      console.log(`🔧 [S031] Main analyzer initialized successfully`);
+    if (this.verbose) {
+      console.log(
+        `🔧 [S031] Analyzer initialized - verbose: ${this.verbose}`
+      );
     }
   }
 
   /**
    * Single file analysis method for testing
-
    */
   analyzeSingle(filePath, options = {}) {
     if (process.env.SUNLINT_DEBUG) {
@@ -141,122 +123,95 @@ class S031Analyzer {
     // Create a Map to track unique violations and prevent duplicates
     const violationMap = new Map();
 
-    // 1. Try Symbol-based analysis first (primary)
-    if (
-      this.config.useSymbolBased &&
-      this.semanticEngine?.project &&
-      this.semanticEngine?.initialized
-    ) {
+    // Symbol-based analysis only
+    if (this.semanticEngine?.project && this.semanticEngine?.initialized) {
       try {
         if (process.env.SUNLINT_DEBUG) {
-          console.log(`🔧 [S031] Trying symbol-based analysis...`);
+          console.log(`🔧 [S031] Running symbol-based analysis...`);
         }
         const sourceFile = this.semanticEngine.project.getSourceFile(filePath);
         if (sourceFile) {
           if (process.env.SUNLINT_DEBUG) {
-            console.log(`🔧 [S031] Source file found, analyzing...`);
+            console.log(
+              `🔧 [S031] Source file found, analyzing with symbol-based...`
+            );
           }
-          const symbolViolations = await this.symbolAnalyzer.analyze(
+
+          const violations = await this.symbolAnalyzer.analyze(
             sourceFile,
             filePath
           );
 
-          // Add to violation map with deduplication
-          symbolViolations.forEach((violation) => {
-            // Create a cookie-specific key to allow multiple violations for same cookie at different locations
-            const cookieName = this.extractCookieName(violation.message) || "";
-            const key = `cookie:${cookieName}:line:${violation.line}:secure`;
+          // Add violations to map to deduplicate and add filePath
+          violations.forEach((v) => {
+            const key = `${v.line}:${v.column}:${v.message}`;
             if (!violationMap.has(key)) {
-              violationMap.set(key, violation);
+              v.analysisStrategy = "symbol-based";
+              v.filePath = filePath;
+              v.file = filePath; // Also add 'file' for compatibility
+              violationMap.set(key, v);
             }
           });
 
           if (process.env.SUNLINT_DEBUG) {
             console.log(
-              `🔧 [S031] Symbol analysis completed: ${symbolViolations.length} violations`
+              `✅ [S031] Symbol-based analysis: ${violations.length} violations`
             );
           }
+
+          const finalViolations = Array.from(violationMap.values());
+          return finalViolations; // Return deduplicated violations with filePath
         } else {
           if (process.env.SUNLINT_DEBUG) {
-            console.log(`🔧 [S031] Source file not found, falling back...`);
+            console.log(`⚠️ [S031] Source file not found in project`);
           }
         }
       } catch (error) {
-        console.warn(`⚠ [S031] Symbol analysis failed:`, error.message);
+        console.warn(`⚠️ [S031] Symbol analysis failed: ${error.message}`);
       }
-    }
-
-    // 2. Try Regex-based analysis (fallback or additional)
-    if (this.config.fallbackToRegex || this.config.regexBasedOnly) {
-      try {
-        if (process.env.SUNLINT_DEBUG) {
-          console.log(`🔧 [S031] Trying regex-based analysis...`);
-        }
-        const regexViolations = await this.regexAnalyzer.analyze(filePath);
-
-        // Add to violation map with deduplication
-        regexViolations.forEach((violation) => {
-          // Create a cookie-specific key to allow multiple violations for same cookie at different locations
-          const cookieName = this.extractCookieName(violation.message) || "";
-          const key = `cookie:${cookieName}:line:${violation.line}:secure`;
-          if (!violationMap.has(key)) {
-            violationMap.set(key, violation);
-          }
-        });
-
-        if (process.env.SUNLINT_DEBUG) {
-          console.log(
-            `🔧 [S031] Regex analysis completed: ${regexViolations.length} violations`
-          );
-        }
-      } catch (error) {
-        console.warn(`⚠ [S031] Regex analysis failed:`, error.message);
+    } else {
+      if (process.env.SUNLINT_DEBUG) {
+        console.log(`🔄 [S031] Symbol analysis conditions check:`);
+        console.log(`  - semanticEngine: ${!!this.semanticEngine}`);
+        console.log(
+          `  - semanticEngine.project: ${!!this.semanticEngine?.project}`
+        );
+        console.log(
+          `  - semanticEngine.initialized: ${this.semanticEngine?.initialized}`
+        );
+        console.log(`🔄 [S031] Symbol analysis unavailable`);
       }
     }
 
-    // Convert Map values to array and add filePath to each violation
-    const finalViolations = Array.from(violationMap.values()).map(
-      (violation) => ({
-        ...violation,
-        filePath: filePath,
-        file: filePath, // Also add 'file' for compatibility
-      })
-    );
-
     if (process.env.SUNLINT_DEBUG) {
-      console.log(
-        `🔧 [S031] File analysis completed: ${finalViolations.length} unique violations`
-      );
+      console.log(`🔧 [S031] Analysis completed: ${violationMap.size} violations`);
     }
-
-    return finalViolations;
+    return Array.from(violationMap.values());
   }
 
   /**
-   * Extract cookie name from violation message for better deduplication
+   * Methods for compatibility with different engine invocation patterns
    */
-  extractCookieName(message) {
-    try {
-      const match = message.match(
-        /Session cookie "([^"]+)"|Session cookie from "([^"]+)"/
-      );
-      return match ? match[1] || match[2] : "";
-    } catch (error) {
-      return "";
-    }
+  async analyzeFileWithSymbols(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
   }
 
-  /**
-   * Clean up resources
+  async analyzeWithSemantics(filePath, options = {}) {
+    return this.analyzeFile(filePath, options);
+  }
 
+  /**
+   * Get analyzer metadata
    */
-  cleanup() {
-    if (this.symbolAnalyzer?.cleanup) {
-      this.symbolAnalyzer.cleanup();
-    }
-    if (this.regexAnalyzer?.cleanup) {
-      this.regexAnalyzer.cleanup();
-    }
+  getMetadata() {
+    return {
+      rule: "S031",
+      name: "Set Secure flag for Session Cookies",
+      category: "security",
+      type: "symbol-based",
+      description:
+        "Uses symbol-based analysis to detect session cookies missing Secure flag",
+    };
   }
 }
 

package/rules/security/S031_secure_session_cookies/regex-based-analyzer.js

@@ -1,296 +0,0 @@
-/**
- * S031 Regex-Based Analyzer - Set Secure flag for Session Cookies
- * Fallback analysis using regex patterns
-
- */
-
-const fs = require("fs");
-
-class S031RegexBasedAnalyzer {
-  constructor(semanticEngine = null) {
-    this.semanticEngine = semanticEngine;
-    this.ruleId = "S031";
-    this.category = "security";
-
-    // Session cookie indicators
-    this.sessionIndicators = [
-      "session",
-      "sessionid",
-      "sessid",
-      "jsessionid",
-      "phpsessid",
-      "asp.net_sessionid",
-      "connect.sid",
-      "auth",
-      "token",
-      "jwt",
-      "csrf",
-    ];
-
-    // Regex patterns for cookie detection
-    this.cookiePatterns = [
-      // Express/Node.js patterns
-      /res\.cookie\s*\(\s*['"`]([^'"`]+)['"`]\s*,([^)]+)\)/gi,
-      /response\.cookie\s*\(\s*['"`]([^'"`]+)['"`]\s*,([^)]+)\)/gi,
-      /\.setCookie\s*\(\s*['"`]([^'"`]+)['"`]\s*,([^)]+)\)/gi,
-
-      // Set-Cookie header patterns
-      /setHeader\s*\(\s*['"`]Set-Cookie['"`]\s*,\s*['"`]([^'"`]+)['"`]\s*\)/gi,
-      /writeHead\s*\([^,]*,\s*{[^}]*['"`]Set-Cookie['"`]\s*:\s*['"`]([^'"`]+)['"`]/gi,
-
-      // Document.cookie assignments
-      /document\.cookie\s*=\s*['"`]([^'"`]+)['"`]/gi,
-
-      // Session middleware patterns
-      /session\s*\(\s*{([^}]+)}/gi,
-      /\.use\s*\(\s*session\s*\(\s*{([^}]+)}/gi,
-    ];
-  }
-
-  /**
-   * Initialize analyzer
-
-   */
-  async initialize(semanticEngine) {
-    this.semanticEngine = semanticEngine;
-    if (process.env.SUNLINT_DEBUG) {
-      console.log(`🔧 [S031] Regex-based analyzer initialized`);
-    }
-  }
-
-  /**
-   * Check if file should be skipped (test files)
-   */
-  shouldSkipFile(filePath) {
-    const testPatterns = [
-      /\.test\.(ts|tsx|js|jsx)$/,
-      /\.spec\.(ts|tsx|js|jsx)$/,
-      /__tests__\//,
-      /__mocks__\//,
-      /\/tests?\//,
-      /\/fixtures?\//,
-    ];
-    return testPatterns.some((pattern) => pattern.test(filePath));
-  }
-
-  /**
-   * Analyze file content using regex patterns
-
-   */
-  async analyze(filePath) {
-    if (process.env.SUNLINT_DEBUG) {
-      console.log(`🔍 [S031] Regex-based analysis for: ${filePath}`);
-    }
-
-    // Skip test files
-    if (this.shouldSkipFile(filePath)) {
-      if (process.env.SUNLINT_DEBUG) {
-        console.log(`⏭ [S031] Skipping test file: ${filePath}`);
-      }
-      return [];
-    }
-
-    let content;
-    try {
-      content = fs.readFileSync(filePath, "utf8");
-    } catch (error) {
-      if (process.env.SUNLINT_DEBUG) {
-        console.error(`❌ [S031] File read error:`, error);
-      }
-      throw error;
-    }
-
-    const violations = [];
-    const lines = content.split("\n");
-
-    // Check each pattern
-    for (const pattern of this.cookiePatterns) {
-      this.checkPattern(pattern, content, lines, violations, filePath);
-    }
-
-    // Check for custom cookie utilities (e.g., StorageUtils.setCookie)
-    this.checkCustomCookieUtilities(content, lines, violations, filePath);
-
-    return violations;
-  }
-
-  /**
-   * Check specific regex pattern for violations
-
-   */
-  checkPattern(pattern, content, lines, violations, filePath) {
-    let match;
-    pattern.lastIndex = 0; // Reset regex state
-
-    while ((match = pattern.exec(content)) !== null) {
-      const matchText = match[0];
-      const cookieName = match[1] || "";
-      const cookieOptions = match[2] || match[1] || "";
-
-      // Check if this is a session cookie
-      if (!this.isSessionCookie(cookieName, matchText)) {
-        continue;
-      }
-
-      // Check if secure flag is present
-      if (!this.hasSecureFlag(cookieOptions, matchText)) {
-        const lineNumber = this.getLineNumber(content, match.index);
-
-        this.addViolation(
-          matchText,
-          lineNumber,
-          violations,
-          `Session cookie "${cookieName || "unknown"}" missing Secure flag`
-        );
-      }
-    }
-  }
-
-  /**
-   * Check if cookie name or context indicates session cookie
-
-   */
-  isSessionCookie(cookieName, matchText) {
-    const textToCheck = (cookieName + " " + matchText).toLowerCase();
-    return this.sessionIndicators.some((indicator) =>
-      textToCheck.includes(indicator.toLowerCase())
-    );
-  }
-
-  /**
-   * Check if secure flag is present in cookie options
-   */
-  hasSecureFlag(cookieOptions, fullMatch) {
-    const textToCheck = cookieOptions + " " + fullMatch;
-
-    // Check for secure config references (likely safe)
-    const secureConfigPatterns = [
-      /\bcookieConfig\b/i,
-      /\bsecureConfig\b/i,
-      /\bsafeConfig\b/i,
-      /\bdefaultConfig\b/i,
-      /\.\.\..*config/i, // spread operator with config
-      /config.*secure/i,
-    ];
-
-    // If using a secure config reference, assume it's safe
-    if (secureConfigPatterns.some((pattern) => pattern.test(textToCheck))) {
-      return true;
-    }
-
-    // Check for various secure flag patterns
-    const securePatterns = [
-      /secure\s*:\s*true/i,
-      /secure\s*=\s*true/i,
-      /;\s*secure\s*[;\s]/i,
-      /;\s*secure$/i,
-      /['"`]\s*secure\s*['"`]/i,
-      /"secure"\s*:\s*true/i,
-      /'secure'\s*:\s*true/i,
-      /\bsecure\b/i, // Simple secure keyword
-    ];
-
-    return securePatterns.some((pattern) => pattern.test(textToCheck));
-  }
-
-  /**
-   * Get line number from content position
-
-   */
-  getLineNumber(content, position) {
-    const beforeMatch = content.substring(0, position);
-    return beforeMatch.split("\n").length;
-  }
-
-  /**
-   * Add violation to results
-
-   */
-  addViolation(source, lineNumber, violations, message) {
-    violations.push({
-      ruleId: this.ruleId,
-      source: source.trim(),
-      category: this.category,
-      line: lineNumber,
-      column: 1,
-      message: `Insecure session cookie: ${message}`,
-      severity: "error",
-    });
-  }
-
-  /**
-   * Check for custom cookie utility functions with variable names
-   * Handles cases like: StorageUtils.setCookie(STORAGE_KEY.ACCESS_TOKEN, value)
-   */
-  checkCustomCookieUtilities(content, lines, violations, filePath) {
-    // Pattern to match custom cookie utilities with variable references
-    // Matches: Utils.setCookie(VARIABLE_NAME, value) or Utils.setCookie(VARIABLE_NAME, value, options)
-    const customCookiePattern = /(\w+\.setCookie)\s*\(\s*([A-Z_][A-Z0-9_.]*)\s*,\s*([^,)]+)(?:\s*,\s*([^)]*))?\s*\)/gi;
-
-    let match;
-    customCookiePattern.lastIndex = 0;
-
-    while ((match = customCookiePattern.exec(content)) !== null) {
-      const methodCall = match[1]; // e.g., "StorageUtils.setCookie"
-      const cookieNameVar = match[2]; // e.g., "STORAGE_KEY.ACCESS_TOKEN"
-      const cookieValue = match[3]; // e.g., "response.user?.access_token || ''"
-      const cookieOptions = match[4] || ""; // e.g., options object if present
-      const matchText = match[0];
-
-      // Check if this looks like a session cookie based on variable name or value
-      if (!this.isSessionCookieLikely(cookieNameVar, cookieValue, matchText)) {
-        continue;
-      }
-
-      // Check if secure flag is present in options
-      if (!this.hasSecureFlag(cookieOptions, matchText)) {
-        const lineNumber = this.getLineNumber(content, match.index);
-
-        // Extract a friendly cookie name from the variable
-        const friendlyCookieName = this.extractFriendlyCookieName(cookieNameVar);
-
-        this.addViolation(
-          matchText,
-          lineNumber,
-          violations,
-          `Session cookie from "${friendlyCookieName}" missing Secure flag - add secure flag to options`
-        );
-      }
-    }
-  }
-
-  /**
-   * Check if cookie variable name or value suggests it's a session cookie
-   */
-  isSessionCookieLikely(varName, value, matchText) {
-    const textToCheck = (varName + " " + value + " " + matchText).toLowerCase();
-
-    // Check against session indicators
-    const isSession = this.sessionIndicators.some((indicator) =>
-      textToCheck.includes(indicator.toLowerCase())
-    );
-
-    // Also check for common patterns like ACCESS_TOKEN, REFRESH_TOKEN, etc.
-    const tokenPatterns = [
-      /access[_-]?token/i,
-      /refresh[_-]?token/i,
-      /auth[_-]?token/i,
-      /id[_-]?token/i,
-      /session/i,
-    ];
-
-    return isSession || tokenPatterns.some(pattern => pattern.test(textToCheck));
-  }
-
-  /**
-   * Extract a friendly cookie name from variable reference
-   * e.g., "STORAGE_KEY.ACCESS_TOKEN" -> "ACCESS_TOKEN"
-   */
-  extractFriendlyCookieName(varName) {
-    // If it has a dot, take the last part
-    const parts = varName.split(".");
-    return parts[parts.length - 1] || varName;
-  }
-}
-
-module.exports = S031RegexBasedAnalyzer;