@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/src/rule-override.ts

@@ -0,0 +1,427 @@
+/**
+ * Rule Override System for C Coding Standards
+ * 
+ * Implements rule override mechanism for category-specific exceptions.
+ * Supports configuration-based overrides and validates override consistency.
+ */
+
+import { Rule, Category, Configuration, RuleSeverity } from './types';
+import { RuleRegistry } from './registry';
+import { ConfigurationManager } from './config-manager';
+
+export interface RuleOverride {
+  ruleId: string;
+  category: Category;
+  action: 'disable' | 'enable' | 'change_severity';
+  newSeverity?: 'ERROR' | 'WARNING' | 'INFO';
+  reason: string;
+  appliedBy?: 'user' | 'category' | 'system';
+}
+
+export interface OverrideValidation {
+  valid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+
+export interface OverrideReport {
+  overrides: RuleOverride[];
+  applied: number;
+  failed: number;
+  warnings: string[];
+}
+
+export class RuleOverrideSystem {
+  private overrides: Map<string, RuleOverride[]> = new Map();
+  
+  constructor(
+    private registry: RuleRegistry,
+    private configManager: ConfigurationManager
+  ) {
+    this.loadConfigurationOverrides();
+  }
+
+  /**
+   * Load overrides from configuration
+   */
+  private loadConfigurationOverrides(): void {
+    const config = this.configManager.getConfiguration();
+    
+    // Load universal rule overrides
+    if (config.c_standards.universal_rules) {
+      for (const [ruleKey, severity] of Object.entries(config.c_standards.universal_rules)) {
+        const ruleId = `universal-${ruleKey}`;
+        
+        if (severity === 'disabled') {
+          this.addOverride({
+            ruleId,
+            category: 'universal' as Category,
+            action: 'disable',
+            reason: 'Disabled in configuration',
+            appliedBy: 'user'
+          });
+        } else if (severity === 'warning') {
+          this.addOverride({
+            ruleId,
+            category: 'universal' as Category,
+            action: 'change_severity',
+            newSeverity: 'WARNING',
+            reason: 'Changed to warning in configuration',
+            appliedBy: 'user'
+          });
+        }
+      }
+    }
+    
+    // Load category-specific overrides
+    if (config.c_standards.category_overrides) {
+      for (const [category, overrides] of Object.entries(config.c_standards.category_overrides)) {
+        this.loadCategoryOverrides(category as Category, overrides);
+      }
+    }
+  }
+
+  /**
+   * Load category-specific overrides
+   */
+  private loadCategoryOverrides(category: Category, overrides: any): void {
+    // Example: embedded category disables dynamic allocation
+    if (category === 'embedded' && overrides.allow_dynamic_allocation === false) {
+      this.addOverride({
+        ruleId: 'universal-memory_safety',
+        category,
+        action: 'change_severity',
+        newSeverity: 'ERROR',
+        reason: 'Embedded systems forbid dynamic allocation',
+        appliedBy: 'category'
+      });
+    }
+    
+    // Example: systems category requires POSIX compliance
+    if (category === 'systems' && overrides.require_posix_compliance === true) {
+      this.addOverride({
+        ruleId: 'systems-posix',
+        category,
+        action: 'enable',
+        reason: 'POSIX compliance required for systems programming',
+        appliedBy: 'category'
+      });
+    }
+    
+    // Example: realtime category enforces determinism
+    if (category === 'realtime' && overrides.enforce_determinism === true) {
+      this.addOverride({
+        ruleId: 'realtime-determinism',
+        category,
+        action: 'change_severity',
+        newSeverity: 'ERROR',
+        reason: 'Determinism is critical for real-time systems',
+        appliedBy: 'category'
+      });
+    }
+  }
+
+  /**
+   * Add a rule override
+   */
+  addOverride(override: RuleOverride): void {
+    const key = `${override.ruleId}:${override.category}`;
+    
+    if (!this.overrides.has(key)) {
+      this.overrides.set(key, []);
+    }
+    
+    this.overrides.get(key)!.push(override);
+  }
+
+  /**
+   * Get overrides for a specific rule and category
+   */
+  getOverrides(ruleId: string, category: Category): RuleOverride[] {
+    const key = `${ruleId}:${category}`;
+    return this.overrides.get(key) || [];
+  }
+
+  /**
+   * Apply overrides to a rule
+   */
+  applyOverrides(rule: Rule, category: Category): Rule {
+    const overrides = this.getOverrides(rule.id, category);
+
+    if (overrides.length === 0) {
+      return rule;
+    }
+
+    // Create a copy of the rule
+    const modifiedRule = { ...rule };
+
+    // Apply each override in order
+    for (const override of overrides) {
+      switch (override.action) {
+        case 'disable':
+          modifiedRule.enabled = false;
+          break;
+
+        case 'enable':
+          modifiedRule.enabled = true;
+          break;
+
+        case 'change_severity':
+          if (override.newSeverity) {
+            modifiedRule.severity = override.newSeverity;
+          }
+          break;
+      }
+    }
+
+    return modifiedRule;
+  }
+
+  /**
+   * Validate override consistency
+   */
+  validateOverrides(): OverrideValidation {
+    const errors: string[] = [];
+    const warnings: string[] = [];
+
+    // Check for conflicting overrides
+    for (const [key, overrideList] of this.overrides) {
+      if (overrideList.length > 1) {
+        // Multiple overrides for the same rule/category
+        const hasConflict = this.checkOverrideConflict(overrideList);
+
+        if (hasConflict) {
+          errors.push(`Conflicting overrides for ${key}: ${overrideList.map(o => o.action).join(', ')}`);
+        } else {
+          warnings.push(`Multiple overrides for ${key} (will be applied in order)`);
+        }
+      }
+    }
+
+    // Check if overridden rules exist
+    for (const [key, overrideList] of this.overrides) {
+      const ruleId = key.split(':')[0];
+      const rule = this.registry.getRule(ruleId);
+
+      if (!rule) {
+        warnings.push(`Override for non-existent rule: ${ruleId}`);
+      }
+    }
+
+    // Check for circular dependencies
+    const circular = this.detectCircularOverrides();
+    if (circular.length > 0) {
+      errors.push(`Circular override dependencies detected: ${circular.join(', ')}`);
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors,
+      warnings
+    };
+  }
+
+  /**
+   * Check if override list has conflicts
+   */
+  private checkOverrideConflict(overrides: RuleOverride[]): boolean {
+    // Check for enable/disable conflicts
+    const hasEnable = overrides.some(o => o.action === 'enable');
+    const hasDisable = overrides.some(o => o.action === 'disable');
+
+    if (hasEnable && hasDisable) {
+      return true;
+    }
+
+    // Check for severity conflicts
+    const severityChanges = overrides
+      .filter(o => o.action === 'change_severity')
+      .map(o => o.newSeverity);
+
+    const uniqueSeverities = new Set(severityChanges);
+    if (uniqueSeverities.size > 1) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Detect circular override dependencies
+   */
+  private detectCircularOverrides(): string[] {
+    // Simplified implementation
+    // In production, use proper graph cycle detection
+    const circular: string[] = [];
+
+    // Check if any override creates a circular dependency
+    // This is a placeholder for demonstration
+
+    return circular;
+  }
+
+  /**
+   * Apply all overrides to rules for a category
+   */
+  applyAllOverrides(rules: Rule[], category: Category): Rule[] {
+    return rules.map(rule => this.applyOverrides(rule, category));
+  }
+
+  /**
+   * Get all overrides
+   */
+  getAllOverrides(): RuleOverride[] {
+    const allOverrides: RuleOverride[] = [];
+
+    for (const overrideList of this.overrides.values()) {
+      allOverrides.push(...overrideList);
+    }
+
+    return allOverrides;
+  }
+
+  /**
+   * Clear all overrides
+   */
+  clearOverrides(): void {
+    this.overrides.clear();
+  }
+
+  /**
+   * Remove overrides for a specific rule
+   */
+  removeOverrides(ruleId: string, category?: Category): void {
+    if (category) {
+      const key = `${ruleId}:${category}`;
+      this.overrides.delete(key);
+    } else {
+      // Remove all overrides for this rule across all categories
+      const keysToDelete: string[] = [];
+
+      for (const key of this.overrides.keys()) {
+        if (key.startsWith(`${ruleId}:`)) {
+          keysToDelete.push(key);
+        }
+      }
+
+      for (const key of keysToDelete) {
+        this.overrides.delete(key);
+      }
+    }
+  }
+
+  /**
+   * Generate override report
+   */
+  generateReport(): OverrideReport {
+    const allOverrides = this.getAllOverrides();
+    const validation = this.validateOverrides();
+
+    return {
+      overrides: allOverrides,
+      applied: allOverrides.filter(o => o.appliedBy !== undefined).length,
+      failed: validation.errors.length,
+      warnings: validation.warnings
+    };
+  }
+
+  /**
+   * Generate formatted override report
+   */
+  generateFormattedReport(): string {
+    const report = this.generateReport();
+    let output = '# Rule Override Report\n\n';
+
+    output += `## Summary\n\n`;
+    output += `- Total overrides: ${report.overrides.length}\n`;
+    output += `- Applied: ${report.applied}\n`;
+    output += `- Failed: ${report.failed}\n`;
+    output += `- Warnings: ${report.warnings.length}\n\n`;
+
+    if (report.warnings.length > 0) {
+      output += `## Warnings\n\n`;
+      for (const warning of report.warnings) {
+        output += `- ${warning}\n`;
+      }
+      output += '\n';
+    }
+
+    if (report.overrides.length === 0) {
+      output += 'No overrides configured.\n';
+      return output;
+    }
+
+    output += `## Overrides by Category\n\n`;
+
+    // Group by category
+    const byCategory = new Map<Category, RuleOverride[]>();
+
+    for (const override of report.overrides) {
+      if (!byCategory.has(override.category)) {
+        byCategory.set(override.category, []);
+      }
+      byCategory.get(override.category)!.push(override);
+    }
+
+    for (const [category, overrides] of byCategory) {
+      output += `### ${category}\n\n`;
+
+      for (const override of overrides) {
+        output += `- **${override.ruleId}**: ${override.action}`;
+
+        if (override.newSeverity) {
+          output += ` (${override.newSeverity})`;
+        }
+
+        output += `\n  - Reason: ${override.reason}\n`;
+
+        if (override.appliedBy) {
+          output += `  - Applied by: ${override.appliedBy}\n`;
+        }
+      }
+
+      output += '\n';
+    }
+
+    return output;
+  }
+
+  /**
+   * Export overrides to configuration format
+   */
+  exportToConfig(): any {
+    const config: any = {
+      universal_rules: {},
+      category_overrides: {}
+    };
+
+    for (const override of this.getAllOverrides()) {
+      if (override.category === 'universal') {
+        const ruleKey = override.ruleId.replace('universal-', '');
+
+        if (override.action === 'disable') {
+          config.universal_rules[ruleKey] = 'disabled';
+        } else if (override.action === 'change_severity' && override.newSeverity === 'WARNING') {
+          config.universal_rules[ruleKey] = 'warning';
+        } else {
+          config.universal_rules[ruleKey] = 'enabled';
+        }
+      } else {
+        if (!config.category_overrides[override.category]) {
+          config.category_overrides[override.category] = {};
+        }
+
+        // Map override to configuration property
+        // This is simplified; in production, use proper mapping
+        config.category_overrides[override.category][override.ruleId] = {
+          action: override.action,
+          severity: override.newSeverity,
+          reason: override.reason
+        };
+      }
+    }
+
+    return config;
+  }
+}
+

package/augment-extensions/coding-standards/c/src/template-engine.ts

@@ -0,0 +1,217 @@
+/**
+ * Template Engine for C Coding Standards
+ * 
+ * Provides template parsing with variable substitution and conditional sections.
+ * Supports {variable} syntax and {#if}/{#each} directives.
+ */
+
+export interface TemplateContext {
+  [key: string]: any;
+}
+
+export interface TemplateDirective {
+  type: 'if' | 'each' | 'variable';
+  condition?: string;
+  variable?: string;
+  content?: string;
+}
+
+export class TemplateEngine {
+  /**
+   * Render a template with the given context
+   */
+  render(template: string, context: TemplateContext): string {
+    let result = template;
+
+    // Process conditional blocks first ({#if condition}...{/if})
+    result = this.processConditionals(result, context);
+
+    // Process each blocks ({#each items}...{/each})
+    result = this.processEach(result, context);
+
+    // Process variable substitutions ({variable})
+    result = this.processVariables(result, context);
+
+    return result;
+  }
+
+  /**
+   * Process conditional blocks
+   */
+  private processConditionals(template: string, context: TemplateContext): string {
+    const ifRegex = /\{#if\s+([^}]+)\}([\s\S]*?)\{\/if\}/g;
+    
+    return template.replace(ifRegex, (match, condition, content) => {
+      if (this.evaluateCondition(condition.trim(), context)) {
+        return content;
+      }
+      return '';
+    });
+  }
+
+  /**
+   * Process each blocks
+   */
+  private processEach(template: string, context: TemplateContext): string {
+    const eachRegex = /\{#each\s+([^}]+)\}([\s\S]*?)\{\/each\}/g;
+    
+    return template.replace(eachRegex, (match, variable, content) => {
+      const varName = variable.trim();
+      const items = this.resolveVariable(varName, context);
+
+      if (!Array.isArray(items)) {
+        return '';
+      }
+
+      return items.map((item, index) => {
+        const itemContext = {
+          ...context,
+          [varName.split('.').pop() || 'item']: item,
+          '@index': index,
+          '@first': index === 0,
+          '@last': index === items.length - 1
+        };
+        return this.processVariables(content, itemContext);
+      }).join('');
+    });
+  }
+
+  /**
+   * Process variable substitutions
+   */
+  private processVariables(template: string, context: TemplateContext): string {
+    const varRegex = /\{([^#\/][^}]*)\}/g;
+    
+    return template.replace(varRegex, (match, variable) => {
+      const varName = variable.trim();
+      const value = this.resolveVariable(varName, context);
+      
+      if (value === undefined || value === null) {
+        return '';
+      }
+      
+      return String(value);
+    });
+  }
+
+  /**
+   * Evaluate a condition
+   */
+  private evaluateCondition(condition: string, context: TemplateContext): boolean {
+    // Handle negation
+    if (condition.startsWith('!')) {
+      return !this.evaluateCondition(condition.substring(1).trim(), context);
+    }
+
+    // Handle equality checks
+    if (condition.includes('==')) {
+      const [left, right] = condition.split('==').map(s => s.trim());
+      const leftValue = this.resolveVariable(left, context);
+      const rightValue = right.startsWith('"') || right.startsWith("'")
+        ? right.slice(1, -1)
+        : this.resolveVariable(right, context);
+      return leftValue == rightValue;
+    }
+
+    // Handle inequality checks
+    if (condition.includes('!=')) {
+      const [left, right] = condition.split('!=').map(s => s.trim());
+      const leftValue = this.resolveVariable(left, context);
+      const rightValue = right.startsWith('"') || right.startsWith("'")
+        ? right.slice(1, -1)
+        : this.resolveVariable(right, context);
+      return leftValue != rightValue;
+    }
+
+    // Simple truthiness check
+    const value = this.resolveVariable(condition, context);
+    return Boolean(value);
+  }
+
+  /**
+   * Resolve a variable from context (supports dot notation)
+   */
+  private resolveVariable(path: string, context: TemplateContext): any {
+    const parts = path.split('.');
+    let value: any = context;
+
+    for (const part of parts) {
+      if (value === undefined || value === null) {
+        return undefined;
+      }
+      value = value[part];
+    }
+
+    return value;
+  }
+
+  /**
+   * Validate template syntax
+   */
+  validate(template: string): { valid: boolean; errors: string[] } {
+    const errors: string[] = [];
+
+    // Check for balanced {#if}/{/if} blocks
+    const ifMatches = template.match(/\{#if\s+[^}]+\}/g) || [];
+    const ifEndMatches = template.match(/\{\/if\}/g) || [];
+    if (ifMatches.length !== ifEndMatches.length) {
+      errors.push(`Unbalanced {#if}/{/if} blocks: ${ifMatches.length} opening, ${ifEndMatches.length} closing`);
+    }
+
+    // Check for balanced {#each}/{/each} blocks
+    const eachMatches = template.match(/\{#each\s+[^}]+\}/g) || [];
+    const eachEndMatches = template.match(/\{\/each\}/g) || [];
+    if (eachMatches.length !== eachEndMatches.length) {
+      errors.push(`Unbalanced {#each}/{/each} blocks: ${eachMatches.length} opening, ${eachEndMatches.length} closing`);
+    }
+
+    // Check for invalid directive syntax
+    const invalidDirectives = template.match(/\{#[^iefl][^}]*\}/g);
+    if (invalidDirectives) {
+      errors.push(`Invalid directives found: ${invalidDirectives.join(', ')}`);
+    }
+
+    return {
+      valid: errors.length === 0,
+      errors
+    };
+  }
+
+  /**
+   * Extract variables used in template
+   */
+  extractVariables(template: string): string[] {
+    const variables = new Set<string>();
+
+    // Extract from variable substitutions
+    const varMatches = template.matchAll(/\{([^#\/][^}]*)\}/g);
+    for (const match of varMatches) {
+      const varName = match[1].trim().split('.')[0];
+      if (varName && !varName.startsWith('@')) {
+        variables.add(varName);
+      }
+    }
+
+    // Extract from conditionals
+    const ifMatches = template.matchAll(/\{#if\s+([^}]+)\}/g);
+    for (const match of ifMatches) {
+      const condition = match[1].trim();
+      const varName = condition.split(/[!=\s]/)[0].trim();
+      if (varName && !varName.startsWith('!')) {
+        variables.add(varName);
+      }
+    }
+
+    // Extract from each blocks
+    const eachMatches = template.matchAll(/\{#each\s+([^}]+)\}/g);
+    for (const match of eachMatches) {
+      const varName = match[1].trim().split('.')[0];
+      if (varName) {
+        variables.add(varName);
+      }
+    }
+
+    return Array.from(variables);
+  }
+}
+