vibecodingmachine-core 2026.2.20-438 → 2026.2.26-1739

package/src/validation/compliance-rules.js

@@ -0,0 +1,127 @@
+/**
+ * Constitutional Compliance Rules
+ * 
+ * Defines the compliance rules and categories for constitutional validation.
+ */
+
+/**
+ * Compliance issue categories
+ */
+const COMPLIANCE_CATEGORIES = {
+  FILE_SIZE: 'file_size',
+  CODE_STRUCTURE: 'code_structure',
+  TESTING: 'testing',
+  DOCUMENTATION: 'documentation',
+  IMPORTS: 'imports',
+  NAMING: 'naming',
+  ARCHITECTURE: 'architecture'
+};
+
+/**
+ * Compliance severity levels
+ */
+const COMPLIANCE_SEVERITY = {
+  ERROR: 'error',
+  WARNING: 'warning',
+  INFO: 'info'
+};
+
+/**
+ * Default compliance rules configuration
+ */
+const DEFAULT_RULES = {
+  // File size rules
+  maxFileSize: {
+    enabled: true,
+    limit: 555,
+    category: COMPLIANCE_CATEGORIES.FILE_SIZE,
+    severity: COMPLIANCE_SEVERITY.ERROR
+  },
+  
+  // Code structure rules
+  noTrailingWhitespace: {
+    enabled: true,
+    category: COMPLIANCE_CATEGORIES.CODE_STRUCTURE,
+    severity: COMPLIANCE_SEVERITY.ERROR
+  },
+  
+  fileEndsWithNewline: {
+    enabled: true,
+    category: COMPLIANCE_CATEGORIES.CODE_STRUCTURE,
+    severity: COMPLIANCE_SEVERITY.INFO
+  },
+  
+  maxLineLength: {
+    enabled: true,
+    limit: 200,
+    category: COMPLIANCE_CATEGORIES.CODE_STRUCTURE,
+    severity: COMPLIANCE_SEVERITY.WARNING
+  },
+  
+  // Testing rules
+  testFirstDevelopment: {
+    enabled: true,
+    category: COMPLIANCE_CATEGORIES.TESTING,
+    severity: COMPLIANCE_SEVERITY.WARNING
+  },
+  
+  // Documentation rules
+  functionDocumentation: {
+    enabled: true,
+    category: COMPLIANCE_CATEGORIES.DOCUMENTATION,
+    severity: COMPLIANCE_SEVERITY.INFO
+  },
+  
+  // Import rules
+  noCircularDependencies: {
+    enabled: true,
+    category: COMPLIANCE_CATEGORIES.IMPORTS,
+    severity: COMPLIANCE_SEVERITY.ERROR
+  },
+  
+  // Naming rules
+  consistentNaming: {
+    enabled: true,
+    category: COMPLIANCE_CATEGORIES.NAMING,
+    severity: COMPLIANCE_SEVERITY.WARNING
+  }
+};
+
+/**
+ * Get rules for specific file type
+ */
+function getRulesForFileType(fileType) {
+  const rules = { ...DEFAULT_RULES };
+  
+  // Adjust rules based on file type
+  switch (fileType) {
+    case 'javascript':
+    case 'typescript':
+      // Add JS/TS specific rules
+      rules.noConsoleStatements = {
+        enabled: false, // Often needed for debugging
+        category: COMPLIANCE_CATEGORIES.CODE_STRUCTURE,
+        severity: COMPLIANCE_SEVERITY.WARNING
+      };
+      break;
+      
+    case 'markdown':
+      // Markdown-specific rules
+      delete rules.maxLineLength; // Markdown can have long lines
+      break;
+      
+    case 'json':
+      // JSON-specific rules
+      delete rules.functionDocumentation;
+      break;
+  }
+  
+  return rules;
+}
+
+module.exports = {
+  COMPLIANCE_CATEGORIES,
+  COMPLIANCE_SEVERITY,
+  DEFAULT_RULES,
+  getRulesForFileType
+};

package/src/validation/constitution-validator-new.js

@@ -0,0 +1,196 @@
+/**
+ * Constitutional Compliance Checker
+ * 
+ * Validates that code and files comply with project constitution requirements.
+ * Ensures adherence to established development principles and standards.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getRulesForFileType } = require('./compliance-rules');
+const {
+  validateFileSize,
+  validateTrailingWhitespace,
+  validateFileEndsWithNewline,
+  validateMaxLineLength,
+  validateFunctionDocumentation,
+  getFileType
+} = require('./file-validators');
+
+/**
+ * Constitutional Compliance Validator
+ */
+class ConstitutionValidator {
+  constructor(options = {}) {
+    this.options = {
+      excludePatterns: options.excludePatterns || [/node_modules/, /\.git/, /dist/, /build/],
+      includePatterns: options.includePatterns || [],
+      maxFileSize: options.maxFileSize || 555,
+      ...options
+    };
+  }
+
+  /**
+   * Validate file for constitutional compliance
+   */
+  validateFile(filePath, options = {}) {
+    const results = [];
+    
+    try {
+      if (!fs.existsSync(filePath)) {
+        return [{
+          rule: 'fileExists',
+          category: 'file_system',
+          severity: 'error',
+          message: 'File does not exist',
+          line: 0,
+          column: 0
+        }];
+      }
+
+      const content = fs.readFileSync(filePath, 'utf8');
+      const fileType = getFileType(filePath);
+      const rules = getRulesForFileType(fileType);
+
+      // Apply all validations
+      results.push(...validateFileSize(filePath, content, rules));
+      results.push(...validateTrailingWhitespace(filePath, content, rules));
+      results.push(...validateFileEndsWithNewline(filePath, content, rules));
+      results.push(...validateMaxLineLength(filePath, content, rules));
+      results.push(...validateFunctionDocumentation(filePath, content, rules));
+
+      return results;
+      
+    } catch (error) {
+      return [{
+        rule: 'validationError',
+        category: 'system',
+        severity: 'error',
+        message: `Validation failed: ${error.message}`,
+        line: 0,
+        column: 0
+      }];
+    }
+  }
+
+  /**
+   * Validate directory recursively
+   */
+  validateDirectory(dirPath, options = {}) {
+    const results = new Map();
+    
+    if (!fs.existsSync(dirPath)) {
+      return new Map([[dirPath, [{
+        rule: 'directoryExists',
+        category: 'file_system',
+        severity: 'error',
+        message: 'Directory does not exist',
+        line: 0,
+        column: 0
+      }]]]);
+    }
+
+    this._scanDirectory(dirPath, results, options);
+    return results;
+  }
+
+  /**
+   * Get compliance summary
+   */
+  getComplianceSummary(validationResults) {
+    const summary = {
+      totalFiles: 0,
+      compliantFiles: 0,
+      nonCompliantFiles: 0,
+      totalIssues: 0,
+      issuesBySeverity: {
+        error: 0,
+        warning: 0,
+        info: 0
+      },
+      issuesByCategory: {}
+    };
+
+    for (const [filePath, issues] of validationResults) {
+      summary.totalFiles++;
+      
+      if (issues.length === 0) {
+        summary.compliantFiles++;
+      } else {
+        summary.nonCompliantFiles++;
+        summary.totalIssues += issues.length;
+        
+        issues.forEach(issue => {
+          summary.issuesBySeverity[issue.severity] = 
+            (summary.issuesBySeverity[issue.severity] || 0) + 1;
+          
+          summary.issuesByCategory[issue.category] = 
+            (summary.issuesByCategory[issue.category] || 0) + 1;
+        });
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Private: Scan directory recursively
+   */
+  _scanDirectory(dirPath, results, options) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      
+      if (entry.isDirectory()) {
+        // Skip excluded directories
+        if (this._shouldExclude(fullPath)) continue;
+        
+        this._scanDirectory(fullPath, results, options);
+      } else if (entry.isFile()) {
+        // Skip excluded files
+        if (this._shouldExclude(fullPath)) continue;
+        
+        const issues = this.validateFile(fullPath, options);
+        results.set(fullPath, issues);
+      }
+    }
+  }
+
+  /**
+   * Private: Check if path should be excluded
+   */
+  _shouldExclude(filePath) {
+    const relativePath = path.relative(process.cwd(), filePath);
+    
+    // Check exclude patterns
+    for (const pattern of this.options.excludePatterns) {
+      if (pattern.test(filePath) || pattern.test(relativePath)) {
+        return true;
+      }
+    }
+    
+    // Check include patterns (if specified)
+    if (this.options.includePatterns.length > 0) {
+      for (const pattern of this.options.includePatterns) {
+        if (pattern.test(filePath) || pattern.test(relativePath)) {
+          return false;
+        }
+      }
+      return true;
+    }
+    
+    return false;
+  }
+}
+
+// Export singleton instance
+const validator = new ConstitutionValidator();
+
+module.exports = {
+  ConstitutionValidator,
+  validator,
+  validateFile: (filePath, options) => validator.validateFile(filePath, options),
+  validateDirectory: (dirPath, options) => validator.validateDirectory(dirPath, options),
+  getComplianceSummary: (results) => validator.getComplianceSummary(results)
+};

package/src/validation/constitution-validator.js

@@ -0,0 +1,17 @@
+/**
+ * Constitutional Compliance Checker
+ * 
+ * Validates that code and files comply with project constitution requirements.
+ * Ensures adherence to established development principles and standards.
+ */
+
+const { ConstitutionValidator, validator, validateFile, validateDirectory, getComplianceSummary } = require('./constitution-validator-new');
+
+// Re-export for backward compatibility
+module.exports = {
+  ConstitutionValidator,
+  validator,
+  validateFile,
+  validateDirectory,
+  getComplianceSummary
+};

package/src/validation/file-validators.js

@@ -0,0 +1,170 @@
+/**
+ * File Validators
+ * 
+ * Individual validation functions for different compliance rules.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { COMPLIANCE_CATEGORIES, COMPLIANCE_SEVERITY } = require('./compliance-rules');
+
+/**
+ * Validate file size
+ */
+function validateFileSize(filePath, content, rules) {
+  const issues = [];
+  const rule = rules.maxFileSize;
+  
+  if (rule && rule.enabled) {
+    const lineCount = content.split('\n').length;
+    if (lineCount > rule.limit) {
+      issues.push({
+        rule: 'maxFileSize',
+        category: rule.category,
+        severity: rule.severity,
+        message: `File has ${lineCount} lines, exceeds limit of ${rule.limit}`,
+        line: lineCount,
+        column: 0
+      });
+    }
+  }
+  
+  return issues;
+}
+
+/**
+ * Validate trailing whitespace
+ */
+function validateTrailingWhitespace(filePath, content, rules) {
+  const issues = [];
+  const rule = rules.noTrailingWhitespace;
+  
+  if (rule && rule.enabled) {
+    const lines = content.split('\n');
+    lines.forEach((line, index) => {
+      if (line.endsWith(' ') || line.endsWith('\t')) {
+        issues.push({
+          rule: 'noTrailingWhitespace',
+          category: rule.category,
+          severity: rule.severity,
+          message: 'Line has trailing whitespace',
+          line: index + 1,
+          column: line.length + 1
+        });
+      }
+    });
+  }
+  
+  return issues;
+}
+
+/**
+ * Validate file ends with newline
+ */
+function validateFileEndsWithNewline(filePath, content, rules) {
+  const issues = [];
+  const rule = rules.fileEndsWithNewline;
+  
+  if (rule && rule.enabled) {
+    if (!content.endsWith('\n')) {
+      issues.push({
+        rule: 'fileEndsWithNewline',
+        category: rule.category,
+        severity: rule.severity,
+        message: 'File does not end with newline',
+        line: content.split('\n').length,
+        column: 0
+      });
+    }
+  }
+  
+  return issues;
+}
+
+/**
+ * Validate maximum line length
+ */
+function validateMaxLineLength(filePath, content, rules) {
+  const issues = [];
+  const rule = rules.maxLineLength;
+  
+  if (rule && rule.enabled) {
+    const lines = content.split('\n');
+    lines.forEach((line, index) => {
+      if (line.length > rule.limit) {
+        issues.push({
+          rule: 'maxLineLength',
+          category: rule.category,
+          severity: rule.severity,
+          message: `Line length ${line.length} exceeds limit of ${rule.limit}`,
+          line: index + 1,
+          column: rule.limit + 1
+        });
+      }
+    });
+  }
+  
+  return issues;
+}
+
+/**
+ * Validate function documentation
+ */
+function validateFunctionDocumentation(filePath, content, rules) {
+  const issues = [];
+  const rule = rules.functionDocumentation;
+  
+  if (rule && rule.enabled) {
+    // Simple heuristic: check for function declarations without preceding comments
+    const lines = content.split('\n');
+    lines.forEach((line, index) => {
+      const functionMatch = line.match(/^\s*(function|const\s+\w+\s*=\s*(function|\([^)]*\)\s*=>))/);
+      if (functionMatch) {
+        // Check preceding lines for documentation
+        const prevLine = index > 0 ? lines[index - 1].trim() : '';
+        const hasDoc = prevLine.startsWith('//') || prevLine.startsWith('/*') || prevLine.startsWith('*');
+        
+        if (!hasDoc) {
+          issues.push({
+            rule: 'functionDocumentation',
+            category: rule.category,
+            severity: rule.severity,
+            message: 'Function appears to lack documentation',
+            line: index + 1,
+            column: functionMatch.index + 1
+          });
+        }
+      }
+    });
+  }
+  
+  return issues;
+}
+
+/**
+ * Get file type from path
+ */
+function getFileType(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  const typeMap = {
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.md': 'markdown',
+    '.json': 'json',
+    '.yml': 'yaml',
+    '.yaml': 'yaml'
+  };
+  
+  return typeMap[ext] || 'text';
+}
+
+module.exports = {
+  validateFileSize,
+  validateTrailingWhitespace,
+  validateFileEndsWithNewline,
+  validateMaxLineLength,
+  validateFunctionDocumentation,
+  getFileType
+};

package/src/validation/line-limit/file-analyzer.js

@@ -0,0 +1,201 @@
+/**
+ * File Line Analyzer
+ * 
+ * Analyzes files to count lines and detect potential issues.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * File line analyzer class
+ */
+class FileLineAnalyzer {
+  constructor() {
+    this.defaultLimit = 555;
+    this.excludedExtensions = new Set([
+      '.json', '.lock', '.log', '.tmp', '.cache', '.map', '.min.js', '.min.css'
+    ]);
+    this.excludedDirectories = new Set([
+      'node_modules', '.git', 'dist', 'build', 'coverage', '.nyc_output'
+    ]);
+  }
+
+  /**
+   * Check if a file should be analyzed based on its path and extension
+   */
+  shouldAnalyze(filePath) {
+    const ext = path.extname(filePath);
+    const dirName = path.basename(path.dirname(filePath));
+    
+    // Skip excluded extensions
+    if (this.excludedExtensions.has(ext)) {
+      return false;
+    }
+    
+    // Skip excluded directories
+    for (const excludedDir of this.excludedDirectories) {
+      if (filePath.includes(`/${excludedDir}/`) || filePath.includes(`\\${excludedDir}\\`)) {
+        return false;
+      }
+    }
+    
+    // Only analyze source code files
+    const sourceExtensions = new Set([
+      '.js', '.jsx', '.ts', '.tsx', '.vue', '.py', '.java', '.cpp', '.c', '.h',
+      '.cs', '.php', '.rb', '.go', '.rs', '.swift', '.kt', '.scala', '.sh',
+      '.html', '.css', '.scss', '.sass', '.less', '.md', '.yml', '.yaml'
+    ]);
+    
+    return sourceExtensions.has(ext);
+  }
+
+  /**
+   * Count lines in a file
+   */
+  countLines(filePath) {
+    try {
+      const content = fs.readFileSync(filePath, 'utf8');
+      return this.countLinesInContent(content);
+    } catch (error) {
+      throw new Error(`Failed to read file ${filePath}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Count lines in content string
+   */
+  countLinesInContent(content) {
+    if (!content) return 0;
+    
+    // Split by lines and filter out empty lines (but keep them for counting)
+    const lines = content.split('\n');
+    
+    // Remove trailing empty line if it exists (POSIX standard requires files to end with newline)
+    if (lines.length > 0 && lines[lines.length - 1] === '') {
+      return lines.length - 1;
+    }
+    
+    return lines.length;
+  }
+
+  /**
+   * Analyze a file and return detailed line information
+   */
+  analyzeFile(filePath, limit = this.defaultLimit) {
+    if (!this.shouldAnalyze(filePath)) {
+      return {
+        filePath,
+        lineCount: 0,
+        limit,
+        shouldAnalyze: false,
+        reason: 'File type excluded from analysis'
+      };
+    }
+
+    try {
+      const lineCount = this.countLines(filePath);
+      const exceedsLimit = lineCount > limit;
+      const percentage = Math.round((lineCount / limit) * 100);
+      
+      // Determine severity based on how much the limit is exceeded
+      let severity = 'info';
+      if (exceedsLimit) {
+        const excessPercentage = percentage - 100;
+        if (excessPercentage > 50) {
+          severity = 'critical';
+        } else if (excessPercentage > 25) {
+          severity = 'error';
+        } else if (excessPercentage > 10) {
+          severity = 'warning';
+        }
+      } else if (percentage > 80) {
+        severity = 'warning';
+      }
+
+      return {
+        filePath,
+        lineCount,
+        limit,
+        exceedsLimit,
+        percentage,
+        severity,
+        shouldAnalyze: true,
+        warnings: this.generateWarnings(lineCount, limit)
+      };
+    } catch (error) {
+      return {
+        filePath,
+        lineCount: 0,
+        limit,
+        shouldAnalyze: false,
+        error: error.message
+      };
+    }
+  }
+
+  /**
+   * Generate warnings for a file based on line count
+   */
+  generateWarnings(lineCount, limit) {
+    const warnings = [];
+    const percentage = Math.round((lineCount / limit) * 100);
+
+    if (percentage > 80 && percentage <= 100) {
+      warnings.push(`File is ${percentage}% of the ${limit} line limit`);
+    }
+
+    if (lineCount > limit) {
+      const excess = lineCount - limit;
+      warnings.push(`File exceeds limit by ${excess} lines (${percentage}% of limit)`);
+    }
+
+    return warnings;
+  }
+
+  /**
+   * Analyze multiple files
+   */
+  analyzeFiles(filePaths, limit = this.defaultLimit) {
+    const results = [];
+    
+    for (const filePath of filePaths) {
+      const result = this.analyzeFile(filePath, limit);
+      results.push(result);
+    }
+    
+    return results;
+  }
+
+  /**
+   * Find files in a directory that should be analyzed
+   */
+  findFilesToAnalyze(directory, recursive = true) {
+    const files = [];
+    
+    try {
+      const entries = fs.readdirSync(directory, { withFileTypes: true });
+      
+      for (const entry of entries) {
+        const fullPath = path.join(directory, entry.name);
+        
+        if (entry.isDirectory() && recursive) {
+          // Skip excluded directories
+          if (!this.excludedDirectories.has(entry.name)) {
+            files.push(...this.findFilesToAnalyze(fullPath, recursive));
+          }
+        } else if (entry.isFile() && this.shouldAnalyze(fullPath)) {
+          files.push(fullPath);
+        }
+      }
+    } catch (error) {
+      // Skip directories that can't be read
+    }
+    
+    return files;
+  }
+}
+
+module.exports = {
+  FileLineAnalyzer
+};