claude-flow-novice 2.9.1 → 2.10.1

package/.claude/skills/cfn-loop-validation/consensus-calculator.js

@@ -0,0 +1,477 @@
+const sqlite3 = require('sqlite3').verbose();
+const path = require('path');
+
+class CFNLoopValidator {
+  constructor(config = {}) {
+    this.mode = config.mode || 'standard';
+    this.maxRetries = config.maxRetries || 10;
+    this.consensusThreshold = this.getThresholdForMode(this.mode);
+    this.validatorCount = config.validatorCount || 3;
+
+    // Initialize database
+    this.db = new sqlite3.Database(path.join(__dirname, 'evidence-chain.db'));
+    this.initializeDatabase();
+  }
+
+  getThresholdForMode(mode) {
+    const thresholds = {
+      mvp: 0.7,
+      standard: 0.85,
+      enterprise: 0.95,
+    };
+    return thresholds[mode] || thresholds.standard;
+  }
+
+  async initializeDatabase() {
+    return new Promise((resolve, reject) => {
+      this.db.serialize(() => {
+        this.db.run(`
+                    CREATE TABLE IF NOT EXISTS validation_evidence (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        template_id TEXT,
+                        validator_id TEXT,
+                        score REAL,
+                        evidence_type TEXT,
+                        evidence_data TEXT,
+                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    )
+                `);
+
+        this.db.run(`
+                    CREATE TABLE IF NOT EXISTS consensus_sessions (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        session_id TEXT,
+                        template_id TEXT,
+                        mode TEXT,
+                        final_score REAL,
+                        consensus_achieved BOOLEAN,
+                        retry_count INTEGER,
+                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    )
+                `);
+
+        this.db.run(`
+                    CREATE TABLE IF NOT EXISTS validator_scores (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        session_id TEXT,
+                        validator_id TEXT,
+                        score REAL,
+                        validation_time INTEGER,
+                        errors TEXT,
+                        timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                    )
+                `);
+
+        resolve();
+      });
+    });
+  }
+
+  async validate(template, templateId = null) {
+    const sessionId = this.generateSessionId();
+    let retryCount = 0;
+    let consensusAchieved = false;
+    let finalScore = 0;
+
+    while (retryCount < this.maxRetries && !consensusAchieved) {
+      try {
+        // Spawn validators in parallel
+        const validators = this.spawnValidators(
+          this.validatorCount,
+          template,
+          sessionId
+        );
+        const results = await Promise.all(validators);
+
+        // Calculate consensus
+        const consensusResult = await this.calculateConsensus(
+          results,
+          sessionId
+        );
+        consensusAchieved = consensusResult.consensusAchieved;
+        finalScore = consensusResult.averageScore;
+
+        if (consensusAchieved) {
+          await this.recordConsensusSession(
+            sessionId,
+            templateId,
+            finalScore,
+            true,
+            retryCount
+          );
+        } else {
+          retryCount++;
+          await new Promise((resolve) =>
+            setTimeout(resolve, 1000 * retryCount)
+          ); // Exponential backoff
+        }
+      } catch (error) {
+        retryCount++;
+        console.error(
+          `Validation attempt ${retryCount} failed:`,
+          error.message
+        );
+      }
+    }
+
+    if (!consensusAchieved) {
+      await this.recordConsensusSession(
+        sessionId,
+        templateId,
+        finalScore,
+        false,
+        retryCount
+      );
+      throw new Error(
+        `Consensus not achieved after ${this.maxRetries} attempts`
+      );
+    }
+
+    return {
+      sessionId,
+      score: finalScore,
+      consensusThreshold: this.consensusThreshold,
+      mode: this.mode,
+      achievedConsensus: true,
+    };
+  }
+
+  spawnValidators(count, template, sessionId) {
+    const validators = [];
+
+    for (let i = 0; i < count; i++) {
+      const validatorId = `validator_${i}_${Date.now()}`;
+      validators.push(this.runValidator(validatorId, template, sessionId));
+    }
+
+    return validators;
+  }
+
+  async runValidator(validatorId, template, sessionId) {
+    const startTime = Date.now();
+
+    try {
+      // Simulate different validation strategies
+      const validationStrategies = [
+        this.detectLoopsBasic,
+        this.detectLoopsAdvanced,
+        this.detectLoopsDeepAnalysis,
+      ];
+
+      const strategy =
+        validationStrategies[
+          Math.floor(Math.random() * validationStrategies.length)
+        ];
+      const score = await strategy.call(this, template);
+      const validationTime = Date.now() - startTime;
+
+      // Store validator result
+      await this.storeValidatorScore(
+        sessionId,
+        validatorId,
+        score,
+        validationTime,
+        null
+      );
+
+      // Store evidence
+      await this.storeEvidence(
+        sessionId,
+        validatorId,
+        'validation_score',
+        JSON.stringify({
+          score,
+          validationTime,
+          strategy: strategy.name,
+        })
+      );
+
+      return {
+        validatorId,
+        score,
+        validationTime,
+        sessionId,
+      };
+    } catch (error) {
+      const validationTime = Date.now() - startTime;
+      await this.storeValidatorScore(
+        sessionId,
+        validatorId,
+        0,
+        validationTime,
+        error.message
+      );
+      throw error;
+    }
+  }
+
+  detectLoopsBasic(template) {
+    // Basic loop detection - simplified for demonstration
+    const resources = template.Resources || {};
+    const hasLoops = Object.keys(resources).length > 10; // Simplified logic
+    return hasLoops ? Math.random() * 0.3 + 0.6 : Math.random() * 0.2 + 0.8;
+  }
+
+  detectLoopsAdvanced(template) {
+    // Advanced loop detection
+    const resources = template.Resources || {};
+    const conditions = template.Conditions || {};
+
+    let loopScore = 0.5;
+
+    // Check for circular references
+    const resourceNames = Object.keys(resources);
+    for (let i = 0; i < resourceNames.length; i++) {
+      for (let j = i + 1; j < resourceNames.length; j++) {
+        if (
+          this.hasCircularDependency(
+            resources[resourceNames[i]],
+            resources[resourceNames[j]]
+          )
+        ) {
+          loopScore += 0.1;
+        }
+      }
+    }
+
+    return Math.min(loopScore, 1.0);
+  }
+
+  detectLoopsDeepAnalysis(template) {
+    // Deep analysis with comprehensive checks
+    const resources = template.Resources || {};
+    const conditions = template.Conditions || {};
+    const outputs = template.Outputs || {};
+
+    let score = 0.5;
+
+    // Analyze resource dependencies
+    score += this.analyzeResourceDependencies(resources) * 0.3;
+
+    // Check condition loops
+    score += this.analyzeConditionLoops(conditions) * 0.2;
+
+    // Check output dependencies
+    score += this.analyzeOutputDependencies(outputs, resources) * 0.2;
+
+    // Check intrinsic function complexity
+    score += this.analyzeIntrinsicFunctions(template) * 0.3;
+
+    return Math.min(score, 1.0);
+  }
+
+  hasCircularDependency(resource1, resource2) {
+    // Simplified circular dependency check
+    return Math.random() > 0.7; // Random for demo
+  }
+
+  analyzeResourceDependencies(resources) {
+    const resourceNames = Object.keys(resources);
+    let complexity = 0;
+
+    resourceNames.forEach((name) => {
+      const resource = resources[name];
+      const properties = resource.Properties || {};
+      const dependsOn = resource.DependsOn || [];
+
+      complexity += dependsOn.length * 0.1;
+    });
+
+    return Math.min(complexity / resourceNames.length, 1.0);
+  }
+
+  analyzeConditionLoops(conditions) {
+    const conditionNames = Object.keys(conditions);
+    let loopCount = 0;
+
+    // Check for condition references
+    conditionNames.forEach((name) => {
+      const condition = conditions[name];
+      if (condition && typeof condition === 'object') {
+        const fn = condition.Fn || condition.Ref || condition.Condition;
+        if (fn && conditionNames.includes(fn)) {
+          loopCount++;
+        }
+      }
+    });
+
+    return Math.min(loopCount / conditionNames.length, 1.0);
+  }
+
+  analyzeOutputDependencies(outputs, resources) {
+    const outputNames = Object.keys(outputs);
+    let dependencyCount = 0;
+
+    outputNames.forEach((name) => {
+      const output = outputs[name];
+      const value = output.Value;
+      if (value && typeof value === 'string') {
+        // Check if output references resources
+        const resourceNames = Object.keys(resources);
+        resourceNames.forEach((resourceName) => {
+          if (
+            value.includes(`!Ref ${resourceName}`) ||
+            value.includes(`!GetAtt ${resourceName}`)
+          ) {
+            dependencyCount++;
+          }
+        });
+      }
+    });
+
+    return Math.min(dependencyCount / outputNames.length, 1.0);
+  }
+
+  analyzeIntrinsicFunctions(template) {
+    const templateString = JSON.stringify(template);
+    const intrinsicFunctions = [
+      'Fn::If',
+      'Fn::Join',
+      'Fn::Select',
+      'Fn::Split',
+      'Fn::FindInMap',
+      'Fn::GetAZs',
+      'Fn::ImportValue',
+      'Fn::GetAtt',
+      'Fn::Join',
+      'Fn::Select',
+      'Fn::Split',
+    ];
+
+    let functionCount = 0;
+    intrinsicFunctions.forEach((fn) => {
+      const regex = new RegExp(`"${fn}"`, 'g');
+      const matches = templateString.match(regex);
+      if (matches) {
+        functionCount += matches.length;
+      }
+    });
+
+    return Math.min(functionCount / 10, 1.0); // Normalize to 0-1
+  }
+
+  async calculateConsensus(results, sessionId) {
+    if (results.length === 0) {
+      return { consensusAchieved: false, averageScore: 0 };
+    }
+
+    const scores = results.map((r) => r.score);
+    const averageScore =
+      scores.reduce((sum, score) => sum + score, 0) / scores.length;
+    const standardDeviation = Math.sqrt(
+      scores.reduce(
+        (sum, score) => sum + Math.pow(score - averageScore, 2),
+        0
+      ) / scores.length
+    );
+
+    const consensusAchieved =
+      averageScore >= this.consensusThreshold && standardDeviation <= 0.1;
+
+    await this.storeEvidence(
+      sessionId,
+      'consensus_calculator',
+      'consensus_result',
+      JSON.stringify({
+        scores,
+        averageScore,
+        standardDeviation,
+        consensusThreshold: this.consensusThreshold,
+        consensusAchieved,
+      })
+    );
+
+    return { consensusAchieved, averageScore, standardDeviation };
+  }
+
+  async storeValidatorScore(
+    sessionId,
+    validatorId,
+    score,
+    validationTime,
+    errors
+  ) {
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(`
+                INSERT INTO validator_scores (session_id, validator_id, score, validation_time, errors)
+                VALUES (?, ?, ?, ?, ?)
+            `);
+
+      stmt.run(
+        [sessionId, validatorId, score, validationTime, errors],
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+
+      stmt.finalize();
+    });
+  }
+
+  async storeEvidence(sessionId, validatorId, evidenceType, evidenceData) {
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(`
+                INSERT INTO validation_evidence (template_id, validator_id, score, evidence_type, evidence_data)
+                VALUES (?, ?, ?, ?, ?)
+            `);
+
+      stmt.run(
+        [sessionId, validatorId, 0, evidenceType, evidenceData],
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+
+      stmt.finalize();
+    });
+  }
+
+  async recordConsensusSession(
+    sessionId,
+    templateId,
+    finalScore,
+    consensusAchieved,
+    retryCount
+  ) {
+    return new Promise((resolve, reject) => {
+      const stmt = this.db.prepare(`
+                INSERT INTO consensus_sessions (session_id, template_id, mode, final_score, consensus_achieved, retry_count)
+                VALUES (?, ?, ?, ?, ?, ?)
+            `);
+
+      stmt.run(
+        [
+          sessionId,
+          templateId,
+          this.mode,
+          finalScore,
+          consensusAchieved,
+          retryCount,
+        ],
+        (err) => {
+          if (err) reject(err);
+          else resolve();
+        }
+      );
+
+      stmt.finalize();
+    });
+  }
+
+  generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  async close() {
+    return new Promise((resolve, reject) => {
+      this.db.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+}
+
+module.exports = CFNLoopValidator;

package/.claude/skills/cfn-loop-validation/evidence-chain.sql

@@ -0,0 +1,163 @@
+-- CFN Loop Validation Evidence Chain Schema
+-- SQLite database schema for storing validation results and audit trails
+
+-- Main validation runs table
+CREATE TABLE IF NOT EXISTS validation_runs (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL UNIQUE,
+    template_id TEXT NOT NULL,
+    template_version TEXT NOT NULL,
+    validation_mode TEXT NOT NULL CHECK (validation_mode IN ('mvp', 'standard', 'enterprise')),
+    status TEXT NOT NULL CHECK (status IN ('pending', 'running', 'completed', 'failed', 'retrying')),
+    start_time INTEGER NOT NULL,
+    end_time INTEGER,
+    consensus_score REAL,
+    consensus_threshold REAL,
+    validator_count INTEGER,
+    max_retries INTEGER,
+    retry_count INTEGER DEFAULT 0,
+    error_message TEXT,
+    created_at INTEGER DEFAULT (strftime('%s', 'now'))
+);
+
+-- Individual validator results table
+CREATE TABLE IF NOT EXISTS validator_results (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL,
+    validator_id TEXT NOT NULL,
+    validator_type TEXT NOT NULL,
+    score REAL NOT NULL CHECK (score >= 0 AND score <= 1),
+    execution_time INTEGER NOT NULL,
+    status TEXT NOT NULL CHECK (status IN ('success', 'failed', 'timeout', 'error')),
+    error_message TEXT,
+    metadata TEXT, -- JSON blob for additional data
+    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+    FOREIGN KEY (run_id) REFERENCES validation_runs(run_id) ON DELETE CASCADE
+);
+
+-- Evidence chain table for detailed validation steps
+CREATE TABLE IF NOT EXISTS evidence_chain (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL,
+    step_type TEXT NOT NULL,
+    step_order INTEGER NOT NULL,
+    validator_id TEXT,
+    input_data TEXT, -- JSON blob
+    output_data TEXT, -- JSON blob
+    validation_result TEXT, -- JSON blob
+    timestamp INTEGER NOT NULL,
+    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+    FOREIGN KEY (run_id) REFERENCES validation_runs(run_id) ON DELETE CASCADE
+);
+
+-- Retry log table for tracking retry attempts
+CREATE TABLE IF NOT EXISTS retry_log (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL,
+    attempt_number INTEGER NOT NULL,
+    delay_ms INTEGER NOT NULL,
+    reason TEXT NOT NULL,
+    consensus_score REAL,
+    validator_count INTEGER,
+    timestamp INTEGER NOT NULL,
+    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+    FOREIGN KEY (run_id) REFERENCES validation_runs(run_id) ON DELETE CASCADE
+);
+
+-- Performance metrics table
+CREATE TABLE IF NOT EXISTS performance_metrics (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL,
+    metric_name TEXT NOT NULL,
+    metric_value REAL NOT NULL,
+    unit TEXT NOT NULL,
+    timestamp INTEGER NOT NULL,
+    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+    FOREIGN KEY (run_id) REFERENCES validation_runs(run_id) ON DELETE CASCADE
+);
+
+-- Error tracking table
+CREATE TABLE IF NOT EXISTS error_tracking (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    run_id TEXT NOT NULL,
+    error_type TEXT NOT NULL,
+    error_message TEXT NOT NULL,
+    stack_trace TEXT,
+    validator_id TEXT,
+    timestamp INTEGER NOT NULL,
+    created_at INTEGER DEFAULT (strftime('%s', 'now')),
+    FOREIGN KEY (run_id) REFERENCES validation_runs(run_id) ON DELETE CASCADE
+);
+
+-- Indexes for performance optimization
+CREATE INDEX IF NOT EXISTS idx_validation_runs_status ON validation_runs(status);
+CREATE INDEX IF NOT EXISTS idx_validation_runs_mode ON validation_runs(validation_mode);
+CREATE INDEX IF NOT EXISTS idx_validation_runs_created_at ON validation_runs(created_at);
+CREATE INDEX IF NOT EXISTS idx_validator_results_run_id ON validator_results(run_id);
+CREATE INDEX IF NOT EXISTS idx_validator_results_validator_id ON validator_results(validator_id);
+CREATE INDEX IF NOT EXISTS idx_validator_results_created_at ON validator_results(created_at);
+CREATE INDEX IF NOT EXISTS idx_evidence_chain_run_id ON evidence_chain(run_id);
+CREATE INDEX IF NOT EXISTS idx_evidence_chain_timestamp ON evidence_chain(timestamp);
+CREATE INDEX IF NOT EXISTS idx_retry_log_run_id ON retry_log(run_id);
+CREATE INDEX IF NOT EXISTS idx_performance_metrics_run_id ON performance_metrics(run_id);
+CREATE INDEX IF NOT EXISTS idx_error_tracking_run_id ON error_tracking(run_id);
+
+-- View for completed validation runs
+CREATE VIEW IF NOT EXISTS completed_validation_runs AS
+SELECT 
+    vr.run_id,
+    vr.template_id,
+    vr.template_version,
+    vr.validation_mode,
+    vr.status,
+    vr.start_time,
+    vr.end_time,
+    vr.consensus_score,
+    vr.consensus_threshold,
+    vr.validator_count,
+    vr.error_message,
+    (vr.end_time - vr.start_time) as duration_ms,
+    COUNT(vr.id) as total_validators,
+    SUM(CASE WHEN vrs.status = 'success' THEN 1 ELSE 0 END) as successful_validators,
+    AVG(vrs.score) as average_score
+FROM validation_runs vr
+LEFT JOIN validator_results vrs ON vr.run_id = vrs.run_id
+WHERE vr.status = 'completed'
+GROUP BY vr.run_id, vr.template_id, vr.template_version, vr.validation_mode, vr.status;
+
+-- View for retry statistics
+CREATE VIEW IF NOT EXISTS retry_statistics AS
+SELECT 
+    rl.run_id,
+    vr.template_id,
+    vr.validation_mode,
+    COUNT(rl.id) as total_retries,
+    MAX(rl.attempt_number) as max_attempt,
+    AVG(rl.delay_ms) as avg_delay_ms,
+    MIN(rl.consensus_score) as min_consensus_score,
+    MAX(rl.consensus_score) as max_consensus_score
+FROM retry_log rl
+JOIN validation_runs vr ON rl.run_id = vr.run_id
+GROUP BY rl.run_id, vr.template_id, vr.validation_mode;
+
+-- Trigger to cleanup old records (optional - uncomment if needed)
+-- CREATE TRIGGER IF NOT EXISTS cleanup_old_records 
+-- AFTER INSERT ON validation_runs
+-- FOR EACH ROW
+-- BEGIN
+--     DELETE FROM validator_results WHERE run_id IN (
+--         SELECT run_id FROM validation_runs WHERE created_at < strftime('%s', 'now') - 2592000 -- 30 days
+--     );
+--     DELETE FROM evidence_chain WHERE run_id IN (
+--         SELECT run_id FROM validation_runs WHERE created_at < strftime('%s', 'now') - 2592000
+--     );
+--     DELETE FROM retry_log WHERE run_id IN (
+--         SELECT run_id FROM validation_runs WHERE created_at < strftime('%s', 'now') - 2592000
+--     );
+--     DELETE FROM performance_metrics WHERE run_id IN (
+--         SELECT run_id FROM validation_runs WHERE created_at < strftime('%s', 'now') - 2592000
+--     );
+--     DELETE FROM error_tracking WHERE run_id IN (
+--         SELECT run_id FROM validation_runs WHERE created_at < strftime('%s', 'now') - 2592000
+--     );
+-- END;