aios-core 2.1.5 → 2.2.0

package/.aios-core/infrastructure/scripts/source-tree-guardian/validator.js

@@ -1,468 +0,0 @@
-/**
- * Source-Tree Guardian - Validator Engine
- *
- * Validates file placements against AIOS source-tree standards.
- *
- * @module source-tree-guardian/validator
- * @version 1.0.0
- * @story 6.8
- */
-
-const fs = require('fs').promises;
-const path = require('path');
-const yaml = require('yaml');
-const { glob } = require('glob');
-
-// Constants
-const DEFAULT_RULES_PATH = path.join(__dirname, 'rules', 'placement-rules.yaml');
-const DEFAULT_NAMING_RULES_PATH = path.join(__dirname, 'rules', 'naming-rules.yaml');
-
-/**
- * Severity levels for violations
- * @enum {string}
- */
-const Severity = {
-  ERROR: 'error',
-  WARNING: 'warning',
-  INFO: 'info',
-};
-
-/**
- * Normalizes a file path for cross-platform compatibility
- * @param {string} filePath - The path to normalize
- * @returns {string} Normalized path with forward slashes
- */
-function normalizePath(filePath) {
-  if (!filePath) {
-    return '';
-  }
-  // Convert backslashes to forward slashes
-  let normalized = filePath.replace(/\\/g, '/');
-  // Remove drive letter for Windows paths (e.g., C:/)
-  normalized = normalized.replace(/^[a-zA-Z]:/, '');
-  // Remove leading slash if present
-  normalized = normalized.replace(/^\/+/, '');
-  return normalized;
-}
-
-/**
- * Checks if a path matches a glob pattern
- * @param {string} filePath - The file path to check
- * @param {string} pattern - The glob pattern
- * @returns {boolean} True if the path matches the pattern
- */
-function matchesPattern(filePath, pattern) {
-  const normalized = normalizePath(filePath);
-  const normalizedPattern = normalizePath(pattern);
-
-  // Simple glob matching
-  const regexPattern = normalizedPattern
-    .replace(/\*\*/g, '.*')
-    .replace(/\*/g, '[^/]*')
-    .replace(/\?/g, '.');
-
-  const regex = new RegExp(`^${regexPattern}$`);
-  return regex.test(normalized);
-}
-
-/**
- * Validates a filename against naming conventions
- * @param {string} filename - The filename to validate
- * @param {string} convention - The naming convention to check
- * @returns {Object} Validation result with isValid and message
- */
-function validateNamingConvention(filename, convention) {
-  const patterns = {
-    'kebab-case': /^[a-z][a-z0-9]*(-[a-z0-9]+)*$/,
-    'camelCase': /^[a-z][a-zA-Z0-9]*$/,
-    'PascalCase': /^[A-Z][a-zA-Z0-9]*$/,
-    'SCREAMING_SNAKE_CASE': /^[A-Z][A-Z0-9]*(_[A-Z0-9]+)*$/,
-  };
-
-  // Remove extension for validation
-  const nameWithoutExt = path.basename(filename, path.extname(filename));
-
-  // Check for special allowed names
-  const allowedNames = ['index', 'README', 'CHANGELOG', 'CLAUDE', 'LICENSE', 'CONTRIBUTING'];
-  if (allowedNames.includes(nameWithoutExt)) {
-    return { isValid: true, message: 'Allowed special filename' };
-  }
-
-  const pattern = patterns[convention];
-  if (!pattern) {
-    return { isValid: true, message: `Unknown convention: ${convention}` };
-  }
-
-  const isValid = pattern.test(nameWithoutExt);
-  return {
-    isValid,
-    message: isValid
-      ? `Valid ${convention}`
-      : `Expected ${convention}, got: ${nameWithoutExt}`,
-  };
-}
-
-/**
- * Loads rules from a YAML file
- * @param {string} rulesPath - Path to the rules file
- * @returns {Promise<Object>} Parsed rules object
- */
-async function loadRules(rulesPath) {
-  try {
-    const content = await fs.readFile(rulesPath, 'utf8');
-    return yaml.parse(content);
-  } catch (error) {
-    if (error.code === 'ENOENT') {
-      console.warn(`Rules file not found: ${rulesPath}`);
-      return { rules: [], violations: [], exclusions: { directories: [], files: [], patterns: [] } };
-    }
-    throw new Error(`Failed to load rules from ${rulesPath}: ${error.message}`);
-  }
-}
-
-/**
- * Checks if a file should be excluded from validation
- * @param {string} filePath - The file path to check
- * @param {Object} exclusions - Exclusion rules
- * @returns {boolean} True if the file should be excluded
- */
-function shouldExclude(filePath, exclusions) {
-  const normalized = normalizePath(filePath);
-  const parts = normalized.split('/');
-
-  // Check directory exclusions
-  if (exclusions.directories) {
-    for (const dir of exclusions.directories) {
-      if (parts.includes(dir)) {
-        return true;
-      }
-    }
-  }
-
-  // Check file exclusions
-  if (exclusions.files) {
-    const filename = path.basename(filePath);
-    for (const pattern of exclusions.files) {
-      if (matchesPattern(filename, pattern)) {
-        return true;
-      }
-    }
-  }
-
-  // Check pattern exclusions
-  if (exclusions.patterns) {
-    for (const pattern of exclusions.patterns) {
-      if (matchesPattern(normalized, pattern)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-/**
- * Validates a single file against placement rules
- * @param {string} filePath - The file path to validate
- * @param {Object} rules - Placement rules
- * @param {string} projectRoot - Project root directory
- * @returns {Object} Validation result with violations
- */
-function validateFilePlacement(filePath, rules, projectRoot) {
-  const relativePath = normalizePath(path.relative(projectRoot, filePath));
-  const filename = path.basename(filePath);
-  const violations = [];
-
-  // Check against violation rules (anti-patterns)
-  if (rules.violations) {
-    for (const violation of rules.violations) {
-      // Check if file matches violation pattern
-      if (violation.at_root && matchesPattern(relativePath, violation.pattern)) {
-        // Check exclusions for this violation
-        if (violation.exclude_patterns) {
-          const excluded = violation.exclude_patterns.some((p) =>
-            matchesPattern(relativePath, p),
-          );
-          if (excluded) {
-            continue;
-          }
-        }
-
-        violations.push({
-          type: 'placement',
-          severity: violation.severity || Severity.ERROR,
-          file: relativePath,
-          message: violation.message,
-          suggestedLocation: violation.suggested_location,
-          ruleId: violation.id,
-        });
-      }
-    }
-  }
-
-  return {
-    file: relativePath,
-    violations,
-    isValid: violations.length === 0,
-  };
-}
-
-/**
- * Gets staged files from git
- * @param {string} projectRoot - Project root directory
- * @returns {Promise<string[]>} List of staged file paths
- */
-async function getStagedFiles(projectRoot) {
-  const { execSync } = require('child_process');
-  try {
-    const output = execSync('git diff --cached --name-only --diff-filter=ACM', {
-      cwd: projectRoot,
-      encoding: 'utf8',
-    });
-    return output.trim().split('\n').filter(Boolean);
-  } catch (error) {
-    console.warn('Failed to get staged files:', error.message);
-    return [];
-  }
-}
-
-/**
- * Main validator class
- */
-class SourceTreeValidator {
-  /**
-   * Creates a new SourceTreeValidator instance
-   * @param {Object} options - Validator options
-   * @param {string} options.projectRoot - Project root directory
-   * @param {string} options.rulesPath - Path to placement rules
-   * @param {string} options.namingRulesPath - Path to naming rules
-   * @param {boolean} options.verbose - Enable verbose output
-   */
-  constructor(options = {}) {
-    this.projectRoot = options.projectRoot || process.cwd();
-    this.rulesPath = options.rulesPath || DEFAULT_RULES_PATH;
-    this.namingRulesPath = options.namingRulesPath || DEFAULT_NAMING_RULES_PATH;
-    this.verbose = options.verbose || false;
-    this.rules = null;
-    this.namingRules = null;
-  }
-
-  /**
-   * Initializes the validator by loading rules
-   * @returns {Promise<void>}
-   */
-  async initialize() {
-    this.rules = await loadRules(this.rulesPath);
-    this.namingRules = await loadRules(this.namingRulesPath);
-  }
-
-  /**
-   * Validates all files in the project
-   * @param {Object} options - Validation options
-   * @param {string} options.files - Glob pattern for files to validate
-   * @param {boolean} options.stagedOnly - Only validate staged files
-   * @returns {Promise<Object>} Validation report
-   */
-  async validate(options = {}) {
-    if (!this.rules) {
-      await this.initialize();
-    }
-
-    const startTime = Date.now();
-    let filesToValidate = [];
-
-    if (options.stagedOnly) {
-      filesToValidate = await getStagedFiles(this.projectRoot);
-      filesToValidate = filesToValidate.map((f) => path.join(this.projectRoot, f));
-    } else if (options.files) {
-      filesToValidate = await glob(options.files, {
-        cwd: this.projectRoot,
-        absolute: true,
-        nodir: true,
-      });
-    } else {
-      // Validate all files
-      filesToValidate = await glob('**/*', {
-        cwd: this.projectRoot,
-        absolute: true,
-        nodir: true,
-        ignore: ['**/node_modules/**', '**/.git/**', '**/dist/**', '**/coverage/**'],
-      });
-    }
-
-    const results = {
-      filesScanned: 0,
-      filesExcluded: 0,
-      violations: [],
-      warnings: [],
-      info: [],
-      summary: {
-        errors: 0,
-        warnings: 0,
-        info: 0,
-      },
-      duration: 0,
-    };
-
-    for (const filePath of filesToValidate) {
-      // Check exclusions
-      if (shouldExclude(filePath, this.rules.exclusions || {})) {
-        results.filesExcluded++;
-        continue;
-      }
-
-      results.filesScanned++;
-      const validation = validateFilePlacement(filePath, this.rules, this.projectRoot);
-
-      for (const violation of validation.violations) {
-        switch (violation.severity) {
-          case Severity.ERROR:
-            results.violations.push(violation);
-            results.summary.errors++;
-            break;
-          case Severity.WARNING:
-            results.warnings.push(violation);
-            results.summary.warnings++;
-            break;
-          case Severity.INFO:
-            results.info.push(violation);
-            results.summary.info++;
-            break;
-          default:
-            results.violations.push(violation);
-            results.summary.errors++;
-        }
-      }
-    }
-
-    results.duration = Date.now() - startTime;
-    return results;
-  }
-
-  /**
-   * Validates a single file
-   * @param {string} filePath - Path to the file to validate
-   * @returns {Promise<Object>} Validation result
-   */
-  async validateFile(filePath) {
-    if (!this.rules) {
-      await this.initialize();
-    }
-
-    const absolutePath = path.isAbsolute(filePath)
-      ? filePath
-      : path.join(this.projectRoot, filePath);
-
-    return validateFilePlacement(absolutePath, this.rules, this.projectRoot);
-  }
-
-  /**
-   * Generates fix suggestions for violations
-   * @param {Array} violations - List of violations
-   * @returns {Array} List of fix suggestions
-   */
-  generateFixSuggestions(violations) {
-    return violations.map((violation) => {
-      const suggestion = {
-        file: violation.file,
-        currentLocation: path.dirname(violation.file),
-        suggestedLocation: violation.suggestedLocation || 'No suggestion available',
-        message: violation.message,
-        command: null,
-      };
-
-      if (violation.suggestedLocation) {
-        const filename = path.basename(violation.file);
-        const newPath = path.join(violation.suggestedLocation, filename);
-        suggestion.command = `mv "${violation.file}" "${newPath}"`;
-      }
-
-      return suggestion;
-    });
-  }
-
-  /**
-   * Formats the validation report for console output
-   * @param {Object} report - Validation report
-   * @param {Object} options - Formatting options
-   * @returns {string} Formatted report
-   */
-  formatReport(report, options = {}) {
-    const lines = [];
-    const width = 75;
-    const border = '═'.repeat(width);
-
-    lines.push(`╔${border}╗`);
-    lines.push(`║${'SOURCE-TREE VALIDATION REPORT'.padStart((width + 29) / 2).padEnd(width)}║`);
-    lines.push(`╠${border}╣`);
-    lines.push(`║${''.padEnd(width)}║`);
-    lines.push(`║  Files Scanned: ${String(report.filesScanned).padEnd(width - 19)}║`);
-    lines.push(`║  Violations: ${String(report.summary.errors).padEnd(width - 16)}║`);
-    lines.push(`║  Warnings: ${String(report.summary.warnings).padEnd(width - 14)}║`);
-    lines.push(`║  Duration: ${String(report.duration + 'ms').padEnd(width - 14)}║`);
-    lines.push(`║${''.padEnd(width)}║`);
-
-    if (report.violations.length > 0) {
-      lines.push(`╠${border}╣`);
-      lines.push(`║  VIOLATIONS${' '.repeat(width - 13)}║`);
-      lines.push(`╠${border}╣`);
-      lines.push(`║${''.padEnd(width)}║`);
-
-      for (const violation of report.violations) {
-        lines.push(`║  ❌ ERROR: ${violation.file.substring(0, width - 14).padEnd(width - 13)}║`);
-        lines.push(`║     Problem: ${violation.message.substring(0, width - 16).padEnd(width - 15)}║`);
-        if (violation.suggestedLocation) {
-          lines.push(`║     Suggested: ${violation.suggestedLocation.substring(0, width - 18).padEnd(width - 17)}║`);
-        }
-        lines.push(`║${''.padEnd(width)}║`);
-      }
-    }
-
-    if (report.warnings.length > 0) {
-      lines.push(`╠${border}╣`);
-      lines.push(`║  WARNINGS${' '.repeat(width - 11)}║`);
-      lines.push(`╠${border}╣`);
-      lines.push(`║${''.padEnd(width)}║`);
-
-      for (const warning of report.warnings) {
-        lines.push(`║  ⚠️  WARNING: ${warning.file.substring(0, width - 16).padEnd(width - 15)}║`);
-        lines.push(`║     Problem: ${warning.message.substring(0, width - 16).padEnd(width - 15)}║`);
-        if (warning.suggestedLocation) {
-          lines.push(`║     Suggested: ${warning.suggestedLocation.substring(0, width - 18).padEnd(width - 17)}║`);
-        }
-        lines.push(`║${''.padEnd(width)}║`);
-      }
-    }
-
-    lines.push(`╚${border}╝`);
-
-    if (options.showFixHint && report.summary.errors > 0) {
-      lines.push('');
-      lines.push('Run with --fix to see auto-fix suggestions');
-    }
-
-    return lines.join('\n');
-  }
-
-  /**
-   * Formats the report as JSON
-   * @param {Object} report - Validation report
-   * @returns {string} JSON formatted report
-   */
-  formatJsonReport(report) {
-    return JSON.stringify(report, null, 2);
-  }
-}
-
-// Export for use as module
-module.exports = {
-  SourceTreeValidator,
-  normalizePath,
-  validateNamingConvention,
-  matchesPattern,
-  loadRules,
-  shouldExclude,
-  validateFilePlacement,
-  getStagedFiles,
-  Severity,
-};