@mytechtoday/augment-extensions 1.4.0 → 1.5.0

package/augment-extensions/coding-standards/c/src/prompt-generator.ts

@@ -0,0 +1,307 @@
+/**
+ * AI Prompt Generator for C Coding Standards
+ * 
+ * Generates context-aware prompts for AI code generation by combining
+ * templates with active rules and examples.
+ */
+
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { TemplateEngine, TemplateContext } from './template-engine';
+import { RuleRegistry } from './registry';
+import { ConfigurationManager } from './config-manager';
+import { Category, Rule, Configuration } from './types';
+
+export interface PromptContext {
+  filePath?: string;
+  fileType?: string;
+  category?: Category;
+  functionName?: string;
+  codeContext?: string;
+}
+
+export interface GeneratedPrompt {
+  prompt: string;
+  category: Category;
+  activeRules: Rule[];
+  templateUsed: string;
+}
+
+export class PromptGenerator {
+  private templateEngine: TemplateEngine;
+  private templateCache: Map<Category, string> = new Map();
+  private promptCache: Map<string, GeneratedPrompt> = new Map();
+  private cacheEnabled: boolean = true;
+
+  constructor(
+    private ruleRegistry: RuleRegistry,
+    private configManager: ConfigurationManager,
+    private templatesPath: string
+  ) {
+    this.templateEngine = new TemplateEngine();
+  }
+
+  /**
+   * Generate a prompt for the given context
+   */
+  async generatePrompt(context: PromptContext): Promise<GeneratedPrompt> {
+    // Detect category from context
+    const category = this.detectCategory(context);
+
+    // Check cache
+    const cacheKey = this.getCacheKey(context, category);
+    if (this.cacheEnabled && this.promptCache.has(cacheKey)) {
+      return this.promptCache.get(cacheKey)!;
+    }
+
+    // Load template for category
+    const template = await this.loadTemplate(category);
+
+    // Get active rules for category
+    const activeRules = this.getActiveRulesForCategory(category);
+
+    // Build template context
+    const templateContext = this.buildTemplateContext(
+      category,
+      activeRules,
+      context
+    );
+
+    // Render prompt
+    const prompt = this.templateEngine.render(template, templateContext);
+
+    const result: GeneratedPrompt = {
+      prompt,
+      category,
+      activeRules,
+      templateUsed: `${category}.txt`
+    };
+
+    // Cache result
+    if (this.cacheEnabled) {
+      this.promptCache.set(cacheKey, result);
+    }
+
+    return result;
+  }
+
+  /**
+   * Detect category from context
+   */
+  private detectCategory(context: PromptContext): Category {
+    // If category explicitly provided, use it
+    if (context.category) {
+      return context.category;
+    }
+
+    // Detect from file path
+    if (context.filePath) {
+      const filePath = context.filePath.toLowerCase();
+      
+      if (filePath.includes('kernel') || filePath.includes('module')) {
+        return 'kernel';
+      }
+      if (filePath.includes('driver')) {
+        return 'drivers';
+      }
+      if (filePath.includes('embedded') || filePath.includes('firmware')) {
+        return 'embedded';
+      }
+      if (filePath.includes('rtos') || filePath.includes('realtime')) {
+        return 'realtime';
+      }
+      if (filePath.includes('network') || filePath.includes('socket')) {
+        return 'networking';
+      }
+      if (filePath.includes('legacy') || filePath.includes('compat')) {
+        return 'legacy';
+      }
+    }
+
+    // Detect from code context
+    if (context.codeContext) {
+      const code = context.codeContext.toLowerCase();
+      
+      if (code.includes('module_init') || code.includes('module_exit')) {
+        return 'kernel';
+      }
+      if (code.includes('volatile') && code.includes('isr')) {
+        return 'embedded';
+      }
+      if (code.includes('socket') || code.includes('htons')) {
+        return 'networking';
+      }
+      if (code.includes('rtos') || code.includes('freertos')) {
+        return 'realtime';
+      }
+    }
+
+    // Default to systems programming
+    return 'systems';
+  }
+
+  /**
+   * Load template for category
+   */
+  private async loadTemplate(category: Category): Promise<string> {
+    // Check cache
+    if (this.templateCache.has(category)) {
+      return this.templateCache.get(category)!;
+    }
+
+    // Load from file
+    const templatePath = path.join(this.templatesPath, 'prompts', `${category}.txt`);
+    const template = await fs.readFile(templatePath, 'utf-8');
+
+    // Validate template
+    const validation = this.templateEngine.validate(template);
+    if (!validation.valid) {
+      throw new Error(`Invalid template for ${category}: ${validation.errors.join(', ')}`);
+    }
+
+    // Cache template
+    this.templateCache.set(category, template);
+
+    return template;
+  }
+
+  /**
+   * Get active rules for category
+   */
+  private getActiveRulesForCategory(category: Category): Rule[] {
+    const config = this.configManager.getConfiguration();
+
+    // Get all rules for this category
+    const categoryRules = this.ruleRegistry.getRulesByCategory(category);
+
+    // Get universal rules
+    const universalRules = this.ruleRegistry.getRulesByCategory('universal');
+
+    // Combine and filter for active rules
+    const allRules = [...categoryRules, ...universalRules];
+
+    // Filter by enabled status
+    return allRules.filter(rule => rule.enabled);
+  }
+
+  /**
+   * Build template context from rules and context
+   */
+  private buildTemplateContext(
+    category: Category,
+    rules: Rule[],
+    context: PromptContext
+  ): TemplateContext {
+    const config = this.configManager.getConfiguration();
+
+    // Build context object
+    const templateContext: TemplateContext = {
+      category,
+      c_standard: config?.c_standards.c_standard || 'c11',
+      rules: rules.map(rule => ({
+        id: rule.id,
+        name: rule.name,
+        description: rule.description,
+        severity: rule.severity
+      })),
+      examples: this.extractExamples(rules)
+    };
+
+    // Add file context if available
+    if (context.filePath) {
+      templateContext.file_path = context.filePath;
+    }
+
+    if (context.functionName) {
+      templateContext.function_name = context.functionName;
+    }
+
+    return templateContext;
+  }
+
+  /**
+   * Extract examples from rules
+   */
+  private extractExamples(rules: Rule[]): Array<{ title: string; code: string }> {
+    const examples: Array<{ title: string; code: string }> = [];
+
+    for (const rule of rules) {
+      // Add good examples
+      for (const example of rule.examples.good) {
+        examples.push({
+          title: `${rule.name} - Good Example`,
+          code: example.code
+        });
+      }
+    }
+
+    // Limit to top 5 examples to keep prompt size reasonable
+    return examples.slice(0, 5);
+  }
+
+  /**
+   * Generate cache key
+   */
+  private getCacheKey(context: PromptContext, category: Category): string {
+    const parts = [
+      category,
+      context.filePath || '',
+      context.functionName || '',
+      context.fileType || ''
+    ];
+    return parts.join(':');
+  }
+
+  /**
+   * Clear cache
+   */
+  clearCache(): void {
+    this.promptCache.clear();
+  }
+
+  /**
+   * Enable or disable caching
+   */
+  setCacheEnabled(enabled: boolean): void {
+    this.cacheEnabled = enabled;
+    if (!enabled) {
+      this.clearCache();
+    }
+  }
+
+  /**
+   * Preload all templates
+   */
+  async preloadTemplates(): Promise<void> {
+    const categories: Category[] = [
+      'systems',
+      'embedded',
+      'kernel',
+      'drivers',
+      'realtime',
+      'networking',
+      'legacy'
+    ];
+
+    for (const category of categories) {
+      await this.loadTemplate(category);
+    }
+  }
+
+  /**
+   * Get statistics about cached prompts
+   */
+  getCacheStats(): { size: number; categories: Record<Category, number> } {
+    const stats: { size: number; categories: Record<Category, number> } = {
+      size: this.promptCache.size,
+      categories: {} as Record<Category, number>
+    };
+
+    for (const [, prompt] of this.promptCache) {
+      const category = prompt.category;
+      stats.categories[category] = (stats.categories[category] || 0) + 1;
+    }
+
+    return stats;
+  }
+}

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

@@ -0,0 +1,307 @@
+/**
+ * Rule Evaluator for C Coding Standards
+ * 
+ * Applies active rules to code and generates violation reports.
+ * Supports filtering by category, severity, and configuration.
+ */
+
+import { Rule, Category, Configuration } from './types';
+import { RuleRegistry } from './registry';
+import { ConfigurationManager } from './config-manager';
+
+export interface CodeContext {
+  filePath: string;
+  content: string;
+  category?: Category;
+  language?: string;
+}
+
+export interface RuleViolation {
+  ruleId: string;
+  ruleName: string;
+  severity: 'ERROR' | 'WARNING' | 'INFO';
+  message: string;
+  line?: number;
+  column?: number;
+  suggestion?: string;
+}
+
+export interface EvaluationResult {
+  filePath: string;
+  violations: RuleViolation[];
+  summary: {
+    errors: number;
+    warnings: number;
+    info: number;
+    total: number;
+  };
+}
+
+export interface EvaluationOptions {
+  categories?: Category[];
+  severity?: 'ERROR' | 'WARNING' | 'INFO';
+  enabledOnly?: boolean;
+  maxViolations?: number;
+}
+
+export class RuleEvaluator {
+  constructor(
+    private registry: RuleRegistry,
+    private configManager: ConfigurationManager
+  ) {}
+
+  /**
+   * Evaluate code against active rules
+   */
+  async evaluate(
+    context: CodeContext,
+    options: EvaluationOptions = {}
+  ): Promise<EvaluationResult> {
+    const violations: RuleViolation[] = [];
+    
+    // Get applicable rules
+    const rules = this.getApplicableRules(context, options);
+    
+    // Apply each rule
+    for (const rule of rules) {
+      const ruleViolations = await this.applyRule(rule, context);
+      violations.push(...ruleViolations);
+      
+      // Check max violations limit
+      if (options.maxViolations && violations.length >= options.maxViolations) {
+        break;
+      }
+    }
+    
+    // Generate summary
+    const summary = this.generateSummary(violations);
+    
+    return {
+      filePath: context.filePath,
+      violations,
+      summary
+    };
+  }
+
+  /**
+   * Get rules applicable to the given context
+   */
+  private getApplicableRules(
+    context: CodeContext,
+    options: EvaluationOptions
+  ): Rule[] {
+    const config = this.configManager.getConfiguration();
+    
+    // Start with all rules
+    let rules = this.registry.getAllRules();
+    
+    // Filter by enabled status
+    if (options.enabledOnly !== false) {
+      rules = rules.filter(rule => rule.enabled);
+    }
+    
+    // Filter by category
+    const categories = options.categories || 
+                      (context.category ? [context.category] : config.c_standards.categories);
+    
+    if (categories && categories.length > 0) {
+      rules = rules.filter(rule =>
+        rule.category.some(cat => categories.includes(cat as Category))
+      );
+    }
+    
+    // Filter by severity
+    if (options.severity) {
+      rules = rules.filter(rule => rule.severity === options.severity);
+    }
+    
+    // Apply configuration overrides
+    rules = this.applyConfigurationFilters(rules, config);
+    
+    return rules;
+  }
+
+  /**
+   * Apply configuration-based filters to rules
+   */
+  private applyConfigurationFilters(
+    rules: Rule[],
+    config: Configuration
+  ): Rule[] {
+    return rules.filter(rule => {
+      // Check if rule is disabled in configuration
+      const ruleKey = rule.id.split('-').pop();
+      if (ruleKey && config.c_standards.universal_rules) {
+        const severity = config.c_standards.universal_rules[ruleKey as keyof typeof config.c_standards.universal_rules];
+        if (severity === 'disabled') {
+          return false;
+        }
+      }
+      return true;
+    });
+  }
+
+  /**
+   * Apply a single rule to code context
+   */
+  private async applyRule(
+    rule: Rule,
+    context: CodeContext
+  ): Promise<RuleViolation[]> {
+    const violations: RuleViolation[] = [];
+
+    // Basic pattern matching for demonstration
+    // In production, this would use AST analysis or static analysis tools
+    const lines = context.content.split('\n');
+
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const lineNumber = i + 1;
+
+      // Check for violations based on rule patterns
+      const violation = this.checkLineForViolation(rule, line, lineNumber);
+      if (violation) {
+        violations.push(violation);
+      }
+    }
+
+    return violations;
+  }
+
+  /**
+   * Check a single line for rule violations
+   */
+  private checkLineForViolation(
+    rule: Rule,
+    line: string,
+    lineNumber: number
+  ): RuleViolation | null {
+    // This is a simplified implementation
+    // In production, use proper AST parsing and static analysis
+
+    // Example: Check for naming convention violations
+    if (rule.id.includes('naming')) {
+      // Check for camelCase in function names (should be snake_case)
+      const funcMatch = line.match(/\b([a-z]+[A-Z][a-zA-Z]*)\s*\(/);
+      if (funcMatch) {
+        return {
+          ruleId: rule.id,
+          ruleName: rule.name,
+          severity: rule.severity,
+          message: `Function name '${funcMatch[1]}' should use snake_case, not camelCase`,
+          line: lineNumber,
+          suggestion: `Use ${this.toSnakeCase(funcMatch[1])} instead`
+        };
+      }
+    }
+
+    // Example: Check for memory safety violations
+    if (rule.id.includes('memory')) {
+      // Check for malloc without null check
+      if (line.includes('malloc(') && !line.includes('if')) {
+        return {
+          ruleId: rule.id,
+          ruleName: rule.name,
+          severity: rule.severity,
+          message: 'malloc() call should be followed by null pointer check',
+          line: lineNumber,
+          suggestion: 'Add: if (ptr == NULL) { /* handle error */ }'
+        };
+      }
+    }
+
+    return null;
+  }
+
+  /**
+   * Convert camelCase to snake_case
+   */
+  private toSnakeCase(str: string): string {
+    return str.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+  }
+
+  /**
+   * Generate summary statistics
+   */
+  private generateSummary(violations: RuleViolation[]): EvaluationResult['summary'] {
+    const summary = {
+      errors: 0,
+      warnings: 0,
+      info: 0,
+      total: violations.length
+    };
+
+    for (const violation of violations) {
+      if (violation.severity === 'ERROR') {
+        summary.errors++;
+      } else if (violation.severity === 'WARNING') {
+        summary.warnings++;
+      } else {
+        summary.info++;
+      }
+    }
+
+    return summary;
+  }
+
+  /**
+   * Batch evaluate multiple files
+   */
+  async evaluateBatch(
+    contexts: CodeContext[],
+    options: EvaluationOptions = {}
+  ): Promise<EvaluationResult[]> {
+    const results: EvaluationResult[] = [];
+
+    for (const context of contexts) {
+      const result = await this.evaluate(context, options);
+      results.push(result);
+    }
+
+    return results;
+  }
+
+  /**
+   * Generate a formatted report
+   */
+  generateReport(results: EvaluationResult[]): string {
+    let report = '# C Coding Standards Evaluation Report\n\n';
+
+    // Overall summary
+    const totalViolations = results.reduce((sum, r) => sum + r.summary.total, 0);
+    const totalErrors = results.reduce((sum, r) => sum + r.summary.errors, 0);
+    const totalWarnings = results.reduce((sum, r) => sum + r.summary.warnings, 0);
+    const totalInfo = results.reduce((sum, r) => sum + r.summary.info, 0);
+
+    report += `## Summary\n\n`;
+    report += `- Files evaluated: ${results.length}\n`;
+    report += `- Total violations: ${totalViolations}\n`;
+    report += `- Errors: ${totalErrors}\n`;
+    report += `- Warnings: ${totalWarnings}\n`;
+    report += `- Info: ${totalInfo}\n\n`;
+
+    // Per-file details
+    report += `## Details\n\n`;
+
+    for (const result of results) {
+      if (result.violations.length === 0) {
+        continue;
+      }
+
+      report += `### ${result.filePath}\n\n`;
+      report += `Violations: ${result.summary.total} (${result.summary.errors} errors, ${result.summary.warnings} warnings, ${result.summary.info} info)\n\n`;
+
+      for (const violation of result.violations) {
+        report += `- **[${violation.severity}]** Line ${violation.line}: ${violation.message}\n`;
+        if (violation.suggestion) {
+          report += `  - Suggestion: ${violation.suggestion}\n`;
+        }
+      }
+
+      report += '\n';
+    }
+
+    return report;
+  }
+}
+