import init, { CohomologyEngine } from 'prime-radiant-advanced-wasm';

await init();

class CoherentRAG {
  constructor(embeddingDim = 768) {
    this.checker = new CohomologyEngine(embeddingDim);
    this.threshold = 0.5;
  }

  async retrieve(query, vectorDB, k = 5) {
    // Get candidates from vector DB
    const candidates = await vectorDB.search(query, k * 2);

    // Build coherence graph
    this.checker = new CohomologyEngine(768); // Reset
    candidates.forEach((doc, i) => {
      this.checker.add_node(`doc${i}`, doc.embedding);
    });

    // Connect by similarity
    for (let i = 0; i < candidates.length; i++) {
      for (let j = i + 1; j < candidates.length; j++) {
        const sim = this.cosineSim(candidates[i].embedding, candidates[j].embedding);
        if (sim > 0.3) {
          this.checker.add_edge(`doc${i}`, `doc${j}`, sim);
        }
      }
    }

    // Check coherence
    const energy = this.checker.sheaf_laplacian_energy();

    if (energy > this.threshold) {
      // Incoherent - find the most connected subset
      return this.findCoherentSubset(candidates, k);
    }

    return candidates.slice(0, k);
  }

  findCoherentSubset(candidates, k) {
    // Greedy: start with best match, add only coherent docs
    const result = [candidates[0]];

    for (let i = 1; i < candidates.length && result.length < k; i++) {
      const testSet = [...result, candidates[i]];

      // Check if adding this doc maintains coherence
      this.checker = new CohomologyEngine(768);
      testSet.forEach((doc, j) => this.checker.add_node(`doc${j}`, doc.embedding));

      for (let a = 0; a < testSet.length; a++) {
        for (let b = a + 1; b < testSet.length; b++) {
          const sim = this.cosineSim(testSet[a].embedding, testSet[b].embedding);
          this.checker.add_edge(`doc${a}`, `doc${b}`, sim);
        }
      }

      if (this.checker.sheaf_laplacian_energy() <= this.threshold) {
        result.push(candidates[i]);
      }
    }

    return result;
  }

  cosineSim(a, b) {
    let dot = 0, normA = 0, normB = 0;
    for (let i = 0; i < a.length; i++) {
      dot += a[i] * b[i];
      normA += a[i] * a[i];
      normB += b[i] * b[i];
    }
    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
  }
}

// Usage
const rag = new CoherentRAG();
const docs = await rag.retrieve("What is machine learning?", myVectorDB);

import init, { SpectralEngine } from 'prime-radiant-advanced-wasm';

await init();

class SwarmMonitor {
  constructor() {
    this.engine = new SpectralEngine();
    this.agents = new Map();
    this.history = [];
  }

  registerAgent(agentId) {
    this.agents.set(agentId, { messages: 0, lastSeen: Date.now() });
    this.rebuildGraph();
  }

  recordCommunication(fromAgent, toAgent) {
    this.agents.get(fromAgent).messages++;
    this.agents.get(toAgent).lastSeen = Date.now();
    this.rebuildGraph();
  }

  rebuildGraph() {
    this.engine = new SpectralEngine();

    for (const [id, data] of this.agents) {
      this.engine.add_node(id);
    }

    // Add edges based on communication patterns
    // (In real app, track actual message flows)
    for (const [id1] of this.agents) {
      for (const [id2] of this.agents) {
        if (id1 < id2) {
          this.engine.add_edge(id1, id2, 1.0);
        }
      }
    }
  }

  getHealthReport() {
    const risk = this.engine.predict_collapse_risk();
    const fiedler = this.engine.compute_fiedler_value();
    const cheeger = this.engine.compute_cheeger_constant();

    this.history.push({ time: Date.now(), risk, fiedler, cheeger });

    // Keep last hour
    const oneHourAgo = Date.now() - 3600000;
    this.history = this.history.filter(h => h.time > oneHourAgo);

    // Detect trend
    const trend = this.history.length > 10
      ? (this.history[this.history.length - 1].risk - this.history[0].risk) / this.history.length
      : 0;

    return {
      status: risk < 0.3 ? 'healthy' : risk < 0.6 ? 'warning' : 'critical',
      collapseRisk: risk,
      connectivity: fiedler,
      partitionResistance: cheeger,
      trend: trend > 0.01 ? 'degrading' : trend < -0.01 ? 'improving' : 'stable',
      recommendation: this.getRecommendation(risk, fiedler)
    };
  }

  getRecommendation(risk, fiedler) {
    if (risk > 0.7) {
      return 'CRITICAL: Add redundant connections or spawn backup agents immediately';
    }
    if (fiedler < 0.1) {
      return 'WARNING: System is loosely connected. Consider adding coordinator agent.';
    }
    if (risk > 0.4) {
      return 'CAUTION: Monitor closely. Prepare failover procedures.';
    }
    return 'System healthy. No action needed.';
  }
}

// Usage
const monitor = new SwarmMonitor();
monitor.registerAgent('coordinator');
monitor.registerAgent('worker-1');
monitor.registerAgent('worker-2');
monitor.registerAgent('worker-3');

setInterval(() => {
  const report = monitor.getHealthReport();
  console.log(`[${report.status.toUpperCase()}] Risk: ${(report.collapseRisk * 100).toFixed(1)}%`);
  if (report.status !== 'healthy') {
    console.log(`  → ${report.recommendation}`);
  }
}, 30000);

import init, { CausalEngine } from 'prime-radiant-advanced-wasm';

await init();

class ModelExplainer {
  constructor() {
    this.engine = new CausalEngine();
    this.variables = [];
  }

  // Define your model's causal structure
  defineStructure(features, confounders, target) {
    this.engine = new CausalEngine();

    // Add all variables
    features.forEach(f => {
      this.engine.add_variable(f, true);
      this.variables.push(f);
    });

    confounders.forEach(c => {
      this.engine.add_variable(c, true);
      this.variables.push(c);
    });

    this.engine.add_variable(target, true);
    this.variables.push(target);

    // Define causal edges (from domain knowledge)
    // Confounders affect both features and target
    confounders.forEach(c => {
      features.forEach(f => this.engine.add_causal_edge(c, f));
      this.engine.add_causal_edge(c, target);
    });

    // Features affect target
    features.forEach(f => this.engine.add_causal_edge(f, target));

    this.target = target;
  }

  explain(feature) {
    // Check if effect is identifiable
    const identifiable = this.engine.is_identifiable(feature, this.target);

    if (!identifiable) {
      return {
        feature,
        identifiable: false,
        message: `Cannot isolate effect of ${feature} - unmeasured confounders present`
      };
    }

    // Get adjustment set
    const adjustFor = this.engine.get_adjustment_set(feature, this.target);

    // Compute effect
    const effect = this.engine.compute_ate(feature, this.target);

    return {
      feature,
      identifiable: true,
      causalEffect: effect,
      adjustFor,
      interpretation: this.interpret(feature, effect, adjustFor)
    };
  }

  interpret(feature, effect, adjustFor) {
    const direction = effect > 0 ? 'increases' : 'decreases';
    const magnitude = Math.abs(effect) > 0.5 ? 'strongly' : Math.abs(effect) > 0.2 ? 'moderately' : 'slightly';

    let explanation = `${feature} ${magnitude} ${direction} the outcome (effect size: ${effect.toFixed(3)}).`;

    if (adjustFor.length > 0) {
      explanation += ` This accounts for confounding from: ${adjustFor.join(', ')}.`;
    }

    return explanation;
  }

  explainAll() {
    return this.variables
      .filter(v => v !== this.target)
      .map(v => this.explain(v))
      .sort((a, b) => Math.abs(b.causalEffect || 0) - Math.abs(a.causalEffect || 0));
  }
}

// Usage
const explainer = new ModelExplainer();

explainer.defineStructure(
  ['click_history', 'search_terms', 'time_on_page'],  // Features
  ['user_segment', 'device_type'],                      // Confounders
  'conversion'                                          // Target
);

const explanations = explainer.explainAll();
console.log('Feature importance by causal effect:');
explanations.forEach((exp, i) => {
  console.log(`${i + 1}. ${exp.interpretation}`);
});

import init, { QuantumEngine } from 'prime-radiant-advanced-wasm';

await init();

class EmbeddingQA {
  constructor() {
    this.engine = new QuantumEngine();
  }

  analyze(embeddings, sampleSize = 500) {
    this.engine = new QuantumEngine();

    // Sample if too large
    const sample = embeddings.length > sampleSize
      ? this.randomSample(embeddings, sampleSize)
      : embeddings;

    // Add points
    sample.forEach(emb => this.engine.add_point(new Float64Array(emb)));

    // Analyze at multiple scales
    const scales = [0.1, 0.3, 0.5, 0.7, 1.0];
    const analysis = scales.map(scale => ({
      scale,
      betti: this.engine.get_betti_numbers(scale)
    }));

    return {
      sampleSize: sample.length,
      dimensions: sample[0].length,
      scaleAnalysis: analysis,
      issues: this.detectIssues(analysis),
      recommendations: this.getRecommendations(analysis)
    };
  }

  detectIssues(analysis) {
    const issues = [];

    // Check for fragmentation at low scales
    const lowScale = analysis.find(a => a.scale === 0.3);
    if (lowScale && lowScale.betti[0] > 5) {
      issues.push({
        type: 'fragmentation',
        severity: 'high',
        detail: `${lowScale.betti[0]} disconnected clusters at scale 0.3`
      });
    }

    // Check for holes (gaps in coverage)
    const midScale = analysis.find(a => a.scale === 0.5);
    if (midScale && midScale.betti[1] > 0) {
      issues.push({
        type: 'coverage_gaps',
        severity: 'medium',
        detail: `${midScale.betti[1]} topological holes detected`
      });
    }

    // Check connectivity at high scales
    const highScale = analysis.find(a => a.scale === 1.0);
    if (highScale && highScale.betti[0] > 1) {
      issues.push({
        type: 'disconnected_regions',
        severity: 'high',
        detail: 'Embedding space remains disconnected even at large scales'
      });
    }

    return issues;
  }

  getRecommendations(analysis) {
    const recs = [];
    const issues = this.detectIssues(analysis);

    if (issues.some(i => i.type === 'fragmentation')) {
      recs.push('Add more training data to connect isolated clusters');
      recs.push('Consider using contrastive learning to improve embedding density');
    }

    if (issues.some(i => i.type === 'coverage_gaps')) {
      recs.push('Identify concepts in the gaps and add targeted training examples');
      recs.push('Review data preprocessing - some categories may be underrepresented');
    }

    if (issues.some(i => i.type === 'disconnected_regions')) {
      recs.push('Severe fragmentation detected - consider retraining with different hyperparameters');
      recs.push('Check for data quality issues or labeling errors');
    }

    if (recs.length === 0) {
      recs.push('Embedding space looks healthy!');
    }

    return recs;
  }

  randomSample(arr, n) {
    const shuffled = [...arr].sort(() => 0.5 - Math.random());
    return shuffled.slice(0, n);
  }
}

// Usage
const qa = new EmbeddingQA();

// Assume you have embeddings from your model
const report = qa.analyze(myEmbeddings);

console.log(`Analyzed ${report.sampleSize} embeddings (${report.dimensions}D)`);
console.log('\nIssues found:');
report.issues.forEach(issue => {
  console.log(`  [${issue.severity.toUpperCase()}] ${issue.type}: ${issue.detail}`);
});
console.log('\nRecommendations:');
report.recommendations.forEach((rec, i) => {
  console.log(`  ${i + 1}. ${rec}`);
});