claude-flow-novice 2.6.0 → 2.9.0

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

@@ -1,477 +0,0 @@
-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

@@ -1,163 +0,0 @@
--- 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;