raguard 0.0.0

package/dist/index.js

@@ -0,0 +1,896 @@
+'use strict';
+
+// src/utils/hashing.ts
+function randomId() {
+  const bytes = new Uint8Array(6);
+  if (typeof globalThis.crypto !== "undefined" && globalThis.crypto.getRandomValues) {
+    globalThis.crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function extractNgrams(text, n = 3) {
+  const words = text.toLowerCase().replace(/[^\w\s]/g, "").split(/\s+/);
+  const ngrams = /* @__PURE__ */ new Set();
+  for (let i = 0; i <= words.length - n; i++) {
+    ngrams.add(words.slice(i, i + n).join(" "));
+  }
+  return ngrams;
+}
+function ngramOverlap(text1, text2, n = 3) {
+  const ngrams1 = extractNgrams(text1, n);
+  const ngrams2 = extractNgrams(text2, n);
+  if (ngrams1.size === 0 && ngrams2.size === 0) return 0;
+  let intersection = 0;
+  for (const ng of ngrams1) {
+    if (ngrams2.has(ng)) intersection++;
+  }
+  const union = ngrams1.size + ngrams2.size - intersection;
+  return union === 0 ? 0 : intersection / union;
+}
+function extractDomain(url) {
+  try {
+    const match = url.match(/https?:\/\/(?:www\.)?([^/]+)/i);
+    return match ? match[1].toLowerCase() : null;
+  } catch {
+    return null;
+  }
+}
+var PROMOTIONAL_PATTERNS = [
+  /\bbest\s+ever\b/i,
+  /\b100%\s+(?:safe|secure|guaranteed)\b/i,
+  /\bact\s+now\b/i,
+  /\blimited\s+time\b/i,
+  /\bfree\s+(?:download|trial|offer)\b/i,
+  /\bclick\s+here\b/i
+];
+var REPETITION_THRESHOLD = 3;
+function detectSuspiciousPatterns(text) {
+  const promotional = PROMOTIONAL_PATTERNS.some((p) => p.test(text));
+  const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 10);
+  const sentenceSet = new Set(sentences.map((s) => s.trim().toLowerCase()));
+  const repetitive = sentences.length > 0 && sentences.length - sentenceSet.size >= REPETITION_THRESHOLD;
+  const unicodeAnomalies = /[\u200B-\u200F\u2028-\u202F\uFEFF]/.test(text);
+  let score = 0;
+  if (promotional) score += 0.3;
+  if (repetitive) score += 0.4;
+  if (unicodeAnomalies) score += 0.3;
+  return { promotional, repetitive, unicodeAnomalies, score: Math.min(score, 1) };
+}
+
+// src/models.ts
+var Recommendation = /* @__PURE__ */ ((Recommendation2) => {
+  Recommendation2["PROCEED"] = "proceed";
+  Recommendation2["CITE_WITH_WARNING"] = "cite_with_warning";
+  Recommendation2["BLOCK"] = "block";
+  return Recommendation2;
+})(Recommendation || {});
+var Document = class {
+  content;
+  metadata;
+  doc_id;
+  constructor(input) {
+    if (typeof input === "string") {
+      this.content = input;
+      this.metadata = {};
+      this.doc_id = randomId();
+    } else {
+      this.content = input.content;
+      this.metadata = input.metadata ?? {};
+      this.doc_id = input.doc_id ?? randomId();
+    }
+  }
+};
+
+// src/config.ts
+var DEFAULT_CONFIG = {
+  riskThreshold: 0.7,
+  warningThreshold: 0.4,
+  enabledDetectors: [
+    "consensus_clustering",
+    "semantic_anomaly",
+    "source_reputation"
+  ],
+  consensus: {
+    similarityThreshold: 0.75,
+    minClusterSize: 2,
+    weightSimilarity: 0.4,
+    weightSourceDiversity: 0.3,
+    weightTemporal: 0.2,
+    weightLexical: 0.1
+  },
+  anomaly: {
+    contamination: 0.1,
+    minRelevanceScore: 0.3
+  },
+  reputation: {
+    unknownDomainScore: 0.4,
+    metadataWeight: 0.2,
+    contentQualityWeight: 0.15
+  }
+};
+function mergeConfig(overrides) {
+  if (!overrides) return { ...DEFAULT_CONFIG };
+  return {
+    riskThreshold: overrides.riskThreshold ?? DEFAULT_CONFIG.riskThreshold,
+    warningThreshold: overrides.warningThreshold ?? DEFAULT_CONFIG.warningThreshold,
+    enabledDetectors: overrides.enabledDetectors ?? [...DEFAULT_CONFIG.enabledDetectors],
+    consensus: { ...DEFAULT_CONFIG.consensus, ...overrides.consensus },
+    anomaly: { ...DEFAULT_CONFIG.anomaly, ...overrides.anomaly },
+    reputation: { ...DEFAULT_CONFIG.reputation, ...overrides.reputation }
+  };
+}
+
+// src/detectors/base.ts
+var BaseDetector = class {
+};
+
+// src/utils/math.ts
+function dot(a, b) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    sum += a[i] * b[i];
+  }
+  return sum;
+}
+function norm(a) {
+  let sum = 0;
+  for (let i = 0; i < a.length; i++) {
+    sum += a[i] * a[i];
+  }
+  return Math.sqrt(sum);
+}
+function cosineSimilarity(a, b) {
+  const d = dot(a, b);
+  const na = norm(a);
+  const nb = norm(b);
+  if (na === 0 || nb === 0) return 0;
+  return d / (na * nb);
+}
+function cosineSimilarityMatrix(vectors) {
+  const n = vectors.length;
+  const matrix = Array.from(
+    { length: n },
+    () => new Array(n).fill(0)
+  );
+  const norms = vectors.map(norm);
+  for (let i = 0; i < n; i++) {
+    matrix[i][i] = 1;
+    for (let j = i + 1; j < n; j++) {
+      const sim = norms[i] === 0 || norms[j] === 0 ? 0 : dot(vectors[i], vectors[j]) / (norms[i] * norms[j]);
+      matrix[i][j] = sim;
+      matrix[j][i] = sim;
+    }
+  }
+  return matrix;
+}
+function mean(arr) {
+  if (arr.length === 0) return 0;
+  return arr.reduce((a, b) => a + b, 0) / arr.length;
+}
+function std(arr) {
+  if (arr.length === 0) return 0;
+  const m = mean(arr);
+  const variance = arr.reduce((sum, x) => sum + (x - m) ** 2, 0) / arr.length;
+  return Math.sqrt(variance);
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+// src/utils/embeddings.ts
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((w) => w.length > 1);
+}
+function termFrequency(tokens) {
+  const tf = /* @__PURE__ */ new Map();
+  for (const token of tokens) {
+    tf.set(token, (tf.get(token) ?? 0) + 1);
+  }
+  const total = tokens.length;
+  if (total > 0) {
+    for (const [key, val] of tf) {
+      tf.set(key, val / total);
+    }
+  }
+  return tf;
+}
+function buildIdf(tokenizedDocs) {
+  const docFreq = /* @__PURE__ */ new Map();
+  const n = tokenizedDocs.length;
+  for (const tokens of tokenizedDocs) {
+    const unique = new Set(tokens);
+    for (const token of unique) {
+      docFreq.set(token, (docFreq.get(token) ?? 0) + 1);
+    }
+  }
+  const idf = /* @__PURE__ */ new Map();
+  const vocab = [];
+  for (const [term, df] of docFreq) {
+    if (df < n && df > 0) {
+      idf.set(term, Math.log((n + 1) / (df + 1)) + 1);
+      vocab.push(term);
+    }
+  }
+  vocab.sort();
+  return { vocab, idf };
+}
+function encodeTexts(texts) {
+  const tokenizedDocs = texts.map(tokenize);
+  const { vocab, idf } = buildIdf(tokenizedDocs);
+  if (vocab.length === 0) {
+    return texts.map(() => new Array(1).fill(0));
+  }
+  const vectors = [];
+  for (const tokens of tokenizedDocs) {
+    const tf = termFrequency(tokens);
+    const vec = new Array(vocab.length).fill(0);
+    for (let i = 0; i < vocab.length; i++) {
+      const term = vocab[i];
+      const tfVal = tf.get(term) ?? 0;
+      const idfVal = idf.get(term) ?? 0;
+      vec[i] = tfVal * idfVal;
+    }
+    let normVal = 0;
+    for (const v of vec) normVal += v * v;
+    normVal = Math.sqrt(normVal);
+    if (normVal > 0) {
+      for (let i = 0; i < vec.length; i++) {
+        vec[i] /= normVal;
+      }
+    }
+    vectors.push(vec);
+  }
+  return vectors;
+}
+
+// src/detectors/consensus.ts
+function agglomerativeClustering(distanceMatrix, distanceThreshold) {
+  const n = distanceMatrix.length;
+  const clusterOf = Array.from({ length: n }, (_, i) => i);
+  const clusters = /* @__PURE__ */ new Map();
+  for (let i = 0; i < n; i++) {
+    clusters.set(i, [i]);
+  }
+  while (clusters.size > 1) {
+    let minDist = Infinity;
+    let mergeA = -1;
+    let mergeB = -1;
+    const keys = Array.from(clusters.keys());
+    for (let i = 0; i < keys.length; i++) {
+      for (let j = i + 1; j < keys.length; j++) {
+        const membersA2 = clusters.get(keys[i]);
+        const membersB2 = clusters.get(keys[j]);
+        let totalDist = 0;
+        let count = 0;
+        for (const a of membersA2) {
+          for (const b of membersB2) {
+            totalDist += distanceMatrix[a][b];
+            count++;
+          }
+        }
+        const avgDist = totalDist / count;
+        if (avgDist < minDist) {
+          minDist = avgDist;
+          mergeA = keys[i];
+          mergeB = keys[j];
+        }
+      }
+    }
+    if (minDist > distanceThreshold || mergeA === -1) break;
+    const membersB = clusters.get(mergeB);
+    const membersA = clusters.get(mergeA);
+    for (const idx of membersB) {
+      membersA.push(idx);
+      clusterOf[idx] = mergeA;
+    }
+    clusters.delete(mergeB);
+  }
+  const labelMap = /* @__PURE__ */ new Map();
+  let nextLabel = 0;
+  const labels = new Array(n);
+  for (let i = 0; i < n; i++) {
+    const cluster = clusterOf[i];
+    let root = cluster;
+    while (!clusters.has(root)) {
+      for (const [key, members] of clusters) {
+        if (members.includes(i)) {
+          root = key;
+          break;
+        }
+      }
+      break;
+    }
+    if (!labelMap.has(root)) {
+      labelMap.set(root, nextLabel++);
+    }
+    labels[i] = labelMap.get(root);
+  }
+  return labels;
+}
+var ConsensusClusteringDetector = class extends BaseDetector {
+  name = "consensus_clustering";
+  similarityThreshold;
+  minClusterSize;
+  wSim;
+  wSrc;
+  wTemp;
+  wLex;
+  constructor(config) {
+    super();
+    this.similarityThreshold = config.similarityThreshold;
+    this.minClusterSize = config.minClusterSize;
+    this.wSim = config.weightSimilarity;
+    this.wSrc = config.weightSourceDiversity;
+    this.wTemp = config.weightTemporal;
+    this.wLex = config.weightLexical;
+  }
+  detect(documents, options) {
+    if (documents.length < this.minClusterSize) {
+      return {
+        detectorName: this.name,
+        riskScore: 0,
+        flaggedIndices: [],
+        details: { reason: "too_few_documents" }
+      };
+    }
+    const embeddings = options?.embeddings ?? encodeTexts(documents.map((d) => d.content));
+    const simMatrix = cosineSimilarityMatrix(embeddings);
+    const n = documents.length;
+    const distMatrix = Array.from(
+      { length: n },
+      () => new Array(n).fill(0)
+    );
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        distMatrix[i][j] = i === j ? 0 : Math.max(0, Math.min(2, 1 - simMatrix[i][j]));
+      }
+    }
+    const labels = agglomerativeClustering(
+      distMatrix,
+      1 - this.similarityThreshold
+    );
+    const clusterCounts = /* @__PURE__ */ new Map();
+    for (const label of labels) {
+      clusterCounts.set(label, (clusterCounts.get(label) ?? 0) + 1);
+    }
+    const suspiciousClusters = /* @__PURE__ */ new Map();
+    for (const [clusterId, count] of clusterCounts) {
+      if (count >= this.minClusterSize) {
+        suspiciousClusters.set(clusterId, count);
+      }
+    }
+    if (suspiciousClusters.size === 0) {
+      return {
+        detectorName: this.name,
+        riskScore: 0,
+        flaggedIndices: [],
+        details: { clusters_found: 0 }
+      };
+    }
+    const clusterScores = [];
+    const allFlagged = /* @__PURE__ */ new Set();
+    for (const [clusterId, size] of suspiciousClusters) {
+      const members = labels.map((label, idx) => label === clusterId ? idx : -1).filter((idx) => idx >= 0);
+      for (const m of members) allFlagged.add(m);
+      const simUniformity = this.intraClusterSimilarity(simMatrix, members);
+      const sourceDiversity = this.sourceDiversity(documents, members);
+      const temporalScore = this.temporalClustering(documents, members);
+      const lexicalScore = this.lexicalOverlap(documents, members);
+      const clusterRisk = this.wSim * simUniformity + this.wSrc * (1 - sourceDiversity) + this.wTemp * temporalScore + this.wLex * lexicalScore;
+      clusterScores.push({
+        cluster_id: clusterId,
+        size,
+        members,
+        risk_score: Math.round(clusterRisk * 1e4) / 1e4,
+        similarity_uniformity: Math.round(simUniformity * 1e4) / 1e4,
+        source_diversity: Math.round(sourceDiversity * 1e4) / 1e4,
+        temporal_clustering: Math.round(temporalScore * 1e4) / 1e4,
+        lexical_overlap: Math.round(lexicalScore * 1e4) / 1e4
+      });
+    }
+    const overallRisk = Math.max(
+      ...clusterScores.map((cs) => cs.risk_score)
+    );
+    return {
+      detectorName: this.name,
+      riskScore: Math.min(overallRisk, 1),
+      flaggedIndices: Array.from(allFlagged).sort((a, b) => a - b),
+      details: {
+        clusters_found: suspiciousClusters.size,
+        clusters: clusterScores
+      }
+    };
+  }
+  intraClusterSimilarity(simMatrix, members) {
+    if (members.length < 2) return 0;
+    const sims = [];
+    for (let i = 0; i < members.length; i++) {
+      for (let j = i + 1; j < members.length; j++) {
+        sims.push(simMatrix[members[i]][members[j]]);
+      }
+    }
+    return sims.length > 0 ? mean(sims) : 0;
+  }
+  sourceDiversity(documents, members) {
+    if (members.length === 0) return 1;
+    const sources = /* @__PURE__ */ new Set();
+    let unknownCount = 0;
+    for (const idx of members) {
+      const source = documents[idx].metadata.source;
+      if (source) {
+        const domain = extractDomain(source);
+        sources.add(domain ?? "__unknown__");
+      } else {
+        unknownCount++;
+      }
+    }
+    if (unknownCount > 0) sources.add("__unknown__");
+    return sources.size / members.length;
+  }
+  temporalClustering(documents, members) {
+    const dates = [];
+    for (const idx of members) {
+      const dateStr = documents[idx].metadata.date ?? documents[idx].metadata.published_date;
+      if (dateStr) {
+        try {
+          const d = new Date(dateStr);
+          if (!isNaN(d.getTime())) dates.push(d);
+        } catch {
+          continue;
+        }
+      }
+    }
+    if (dates.length < 2) return 0;
+    dates.sort((a, b) => a.getTime() - b.getTime());
+    const spanDays = (dates[dates.length - 1].getTime() - dates[0].getTime()) / 864e5;
+    if (spanDays <= 1) return 1;
+    if (spanDays <= 7) return 0.7;
+    if (spanDays <= 30) return 0.3;
+    return 0;
+  }
+  lexicalOverlap(documents, members) {
+    if (members.length < 2) return 0;
+    const overlaps = [];
+    for (let i = 0; i < members.length; i++) {
+      for (let j = i + 1; j < members.length; j++) {
+        overlaps.push(
+          ngramOverlap(documents[members[i]].content, documents[members[j]].content)
+        );
+      }
+    }
+    return overlaps.length > 0 ? mean(overlaps) : 0;
+  }
+};
+
+// src/detectors/anomaly.ts
+var NEGATION_PATTERNS = [
+  /\bhowever\b/i,
+  /\bbut\b/i,
+  /\bon the contrary\b/i,
+  /\bactually\b.*\bnot\b/i,
+  /\bfalse\b/i,
+  /\bincorrect\b/i,
+  /\bcontradicts?\b/i,
+  /\bdespite\b.*\bclaims?\b/i,
+  /\bis not\b/i,
+  /\bare not\b/i,
+  /\bwas not\b/i,
+  /\bnever\b/i,
+  /\bno evidence\b/i
+];
+function distanceBasedOutlierScores(embeddings, contamination) {
+  const n = embeddings.length;
+  const simMatrix = cosineSimilarityMatrix(embeddings);
+  const avgDistances = [];
+  for (let i = 0; i < n; i++) {
+    let totalDist = 0;
+    for (let j = 0; j < n; j++) {
+      if (i !== j) totalDist += 1 - simMatrix[i][j];
+    }
+    avgDistances.push(totalDist / (n - 1));
+  }
+  const m = mean(avgDistances);
+  const s = std(avgDistances);
+  if (s === 0) {
+    return new Array(n).fill(0.1);
+  }
+  const scores = avgDistances.map((d) => -(d - m) / s);
+  const sorted = [...scores].sort((a, b) => a - b);
+  const cutoffIdx = Math.max(0, Math.floor(n * contamination) - 1);
+  const cutoff = sorted[cutoffIdx];
+  return scores.map((s2) => s2 - cutoff);
+}
+var SemanticAnomalyDetector = class extends BaseDetector {
+  name = "semantic_anomaly";
+  contamination;
+  minRelevanceScore;
+  constructor(config) {
+    super();
+    this.contamination = config.contamination;
+    this.minRelevanceScore = config.minRelevanceScore;
+  }
+  detect(documents, options) {
+    if (documents.length < 3) {
+      return {
+        detectorName: this.name,
+        riskScore: 0,
+        flaggedIndices: [],
+        details: { reason: "too_few_documents_for_anomaly_detection" }
+      };
+    }
+    const embeddings = options?.embeddings ?? encodeTexts(documents.map((d) => d.content));
+    const outlierScores = distanceBasedOutlierScores(
+      embeddings,
+      Math.min(this.contamination, (documents.length - 1) / documents.length)
+    );
+    let relevanceScores = null;
+    const lowRelevanceFlags = [];
+    if (options?.query) {
+      const queryEmb = options.queryEmbedding?.[0] ?? encodeTexts([options.query])[0];
+      relevanceScores = embeddings.map((emb) => cosineSimilarity(emb, queryEmb));
+      for (let i = 0; i < relevanceScores.length; i++) {
+        if (relevanceScores[i] < this.minRelevanceScore) {
+          lowRelevanceFlags.push(i);
+        }
+      }
+    }
+    const contradictionScores = this.detectContradictions(documents);
+    const coordinatedFlags = this.checkCoordinatedInjection(
+      embeddings,
+      relevanceScores
+    );
+    const flagged = /* @__PURE__ */ new Set();
+    const docRisks = new Array(documents.length).fill(0);
+    for (let i = 0; i < outlierScores.length; i++) {
+      if (outlierScores[i] < 0) {
+        const anomalyStrength = Math.abs(outlierScores[i]);
+        docRisks[i] += anomalyStrength * 0.4;
+        if (anomalyStrength > 0.3) flagged.add(i);
+      }
+    }
+    for (let i = 0; i < contradictionScores.length; i++) {
+      docRisks[i] += contradictionScores[i] * 0.3;
+    }
+    for (const i of lowRelevanceFlags) {
+      docRisks[i] += 0.15;
+      flagged.add(i);
+    }
+    for (const i of coordinatedFlags) {
+      docRisks[i] += 0.25;
+      flagged.add(i);
+    }
+    for (let i = 0; i < docRisks.length; i++) {
+      docRisks[i] = clamp(docRisks[i], 0, 1);
+    }
+    const overallRisk = Math.max(...docRisks);
+    return {
+      detectorName: this.name,
+      riskScore: Math.min(overallRisk, 1),
+      flaggedIndices: Array.from(flagged).sort((a, b) => a - b),
+      details: {
+        outlier_scores: outlierScores.map((s) => Math.round(s * 1e4) / 1e4),
+        contradiction_scores: contradictionScores.map(
+          (s) => Math.round(s * 1e4) / 1e4
+        ),
+        relevance_scores: relevanceScores?.map(
+          (s) => Math.round(s * 1e4) / 1e4
+        ) ?? null,
+        coordinated_injection_indices: coordinatedFlags,
+        per_document_risk: docRisks.map(
+          (r) => Math.round(r * 1e4) / 1e4
+        )
+      }
+    };
+  }
+  detectContradictions(documents) {
+    return documents.map((doc) => {
+      const text = doc.content.toLowerCase();
+      const contradictionCount = NEGATION_PATTERNS.filter(
+        (p) => p.test(text)
+      ).length;
+      const wordCount = Math.max(text.split(/\s+/).length, 1);
+      const density = contradictionCount / (wordCount / 100);
+      return Math.min(density * 0.2, 1);
+    });
+  }
+  checkCoordinatedInjection(embeddings, relevanceScores) {
+    if (!relevanceScores) return [];
+    const lowRelevance = relevanceScores.map((s, i) => s < 0.4 ? i : -1).filter((i) => i >= 0);
+    if (lowRelevance.length < 2) return [];
+    const subEmbeddings = lowRelevance.map((i) => embeddings[i]);
+    const simMatrix = cosineSimilarityMatrix(subEmbeddings);
+    const flagged = [];
+    for (let i = 0; i < lowRelevance.length; i++) {
+      let maxSim = 0;
+      for (let j = 0; j < lowRelevance.length; j++) {
+        if (i !== j) maxSim = Math.max(maxSim, simMatrix[i][j]);
+      }
+      if (maxSim > 0.8) flagged.push(lowRelevance[i]);
+    }
+    return flagged;
+  }
+};
+
+// src/detectors/reputation.ts
+var TRUSTED_DOMAINS = {
+  // Security vendors
+  "crowdstrike.com": 0.95,
+  "mandiant.com": 0.95,
+  "paloaltonetworks.com": 0.9,
+  "fortinet.com": 0.9,
+  "sentinelone.com": 0.9,
+  "trendmicro.com": 0.9,
+  "kaspersky.com": 0.85,
+  "sophos.com": 0.9,
+  "elastic.co": 0.85,
+  // Government / standards
+  "nist.gov": 0.95,
+  "cisa.gov": 0.95,
+  "nvd.nist.gov": 0.95,
+  "mitre.org": 0.95,
+  "us-cert.gov": 0.95,
+  // Major tech
+  "microsoft.com": 0.9,
+  "google.com": 0.9,
+  "aws.amazon.com": 0.9,
+  "cloud.google.com": 0.9,
+  "docs.github.com": 0.85,
+  // Academic / research
+  "arxiv.org": 0.85,
+  "ieee.org": 0.9,
+  "acm.org": 0.9,
+  "usenix.org": 0.9,
+  "springer.com": 0.85,
+  // AI / ML specific
+  "openai.com": 0.85,
+  "anthropic.com": 0.85,
+  "huggingface.co": 0.8,
+  "langchain.com": 0.8,
+  "llamaindex.ai": 0.8,
+  // Known documentation
+  "docs.python.org": 0.9,
+  "stackoverflow.com": 0.75,
+  "wikipedia.org": 0.7
+};
+var LOW_TRUST_PATTERNS = [
+  "blogspot.com",
+  "wordpress.com",
+  "medium.com",
+  "substack.com",
+  "pastebin.com",
+  "hastebin.com"
+];
+var EXPECTED_METADATA_FIELDS = ["source", "author", "date", "title"];
+var SourceReputationDetector = class extends BaseDetector {
+  name = "source_reputation";
+  unknownDomainScore;
+  metadataWeight;
+  contentQualityWeight;
+  trustedDomains;
+  constructor(config, customTrustedDomains) {
+    super();
+    this.unknownDomainScore = config.unknownDomainScore;
+    this.metadataWeight = config.metadataWeight;
+    this.contentQualityWeight = config.contentQualityWeight;
+    this.trustedDomains = { ...TRUSTED_DOMAINS, ...customTrustedDomains };
+  }
+  detect(documents, _options) {
+    if (documents.length === 0) {
+      return {
+        detectorName: this.name,
+        riskScore: 0,
+        flaggedIndices: [],
+        details: { reason: "no_documents" }
+      };
+    }
+    const docReputations = [];
+    const flagged = [];
+    for (let i = 0; i < documents.length; i++) {
+      const rep = this.scoreDocument(documents[i]);
+      docReputations.push(rep);
+      if (rep.reputation_score < 0.4) {
+        flagged.push(i);
+      }
+    }
+    const minRep = Math.min(
+      ...docReputations.map((r) => r.reputation_score)
+    );
+    const overallRisk = 1 - minRep;
+    return {
+      detectorName: this.name,
+      riskScore: Math.min(overallRisk, 1),
+      flaggedIndices: flagged,
+      details: {
+        per_document_reputation: docReputations
+      }
+    };
+  }
+  scoreDocument(doc) {
+    const domainScore = this.domainScore(doc);
+    const metadataScore = this.metadataCompleteness(doc);
+    const qualityScore = this.contentQuality(doc);
+    const domainWeight = 1 - this.metadataWeight - this.contentQualityWeight;
+    const finalScore = domainWeight * domainScore + this.metadataWeight * metadataScore + this.contentQualityWeight * qualityScore;
+    return {
+      reputation_score: Math.round(finalScore * 1e4) / 1e4,
+      domain_score: Math.round(domainScore * 1e4) / 1e4,
+      metadata_score: Math.round(metadataScore * 1e4) / 1e4,
+      quality_score: Math.round(qualityScore * 1e4) / 1e4,
+      domain: this.getDomain(doc)
+    };
+  }
+  domainScore(doc) {
+    const domain = this.getDomain(doc);
+    if (!domain) return this.unknownDomainScore;
+    if (domain in this.trustedDomains) {
+      return this.trustedDomains[domain];
+    }
+    const parts = domain.split(".");
+    if (parts.length > 2) {
+      const parent = parts.slice(-2).join(".");
+      if (parent in this.trustedDomains) {
+        return this.trustedDomains[parent] * 0.9;
+      }
+    }
+    for (const pattern of LOW_TRUST_PATTERNS) {
+      if (domain.includes(pattern)) return 0.3;
+    }
+    return this.unknownDomainScore;
+  }
+  getDomain(doc) {
+    const source = doc.metadata.source ?? doc.metadata.url ?? "";
+    return source ? extractDomain(source) : null;
+  }
+  metadataCompleteness(doc) {
+    const present = EXPECTED_METADATA_FIELDS.filter(
+      (field) => doc.metadata[field]
+    ).length;
+    return present / EXPECTED_METADATA_FIELDS.length;
+  }
+  contentQuality(doc) {
+    if (!doc.content.trim()) return 0;
+    const patterns = detectSuspiciousPatterns(doc.content);
+    const penalty = (patterns.promotional ? 0.4 : 0) + (patterns.repetitive ? 0.3 : 0) + (patterns.unicodeAnomalies ? 0.3 : 0);
+    return Math.max(1 - penalty, 0);
+  }
+};
+
+// src/detectors/index.ts
+var DETECTOR_REGISTRY = {
+  consensus_clustering: (config) => new ConsensusClusteringDetector(config.consensus),
+  semantic_anomaly: (config) => new SemanticAnomalyDetector(config.anomaly),
+  source_reputation: (config) => new SourceReputationDetector(config.reputation)
+};
+
+// src/raguard.ts
+var RAGuard = class _RAGuard {
+  config;
+  detectors;
+  constructor(options) {
+    if (options?.apiKey) {
+      throw new Error(
+        'RAGuard API mode is coming soon! For now, use local mode (no API key needed):\n\n  const guard = new RAGuard();  // local mode\n  const result = await guard.scan(docs, { query: "..." });\n\nFollow https://www.raguard.deepseal.ai for API launch updates.'
+      );
+    }
+    this.config = mergeConfig(options?.config);
+    if (options?.detectors) {
+      this.config.enabledDetectors = options.detectors;
+    }
+    this.detectors = this.initDetectors();
+  }
+  initDetectors() {
+    const instances = [];
+    for (const name of this.config.enabledDetectors) {
+      const factory = DETECTOR_REGISTRY[name];
+      if (!factory) {
+        throw new Error(
+          `Unknown detector: ${name}. Available: ${Object.keys(DETECTOR_REGISTRY).join(", ")}`
+        );
+      }
+      instances.push(factory(this.config));
+    }
+    return instances;
+  }
+  /**
+   * Scan documents for adversarial threats.
+   *
+   * @param documents - Array of documents (Document objects, plain objects, or strings).
+   * @param options - Scan options including the original query.
+   * @returns ScanResult with risk scores, flagged documents, and recommendation.
+   */
+  async scan(documents, options) {
+    const start = performance.now();
+    const normalized = _RAGuard.normalizeDocuments(documents);
+    return this.scanLocal(normalized, options?.query, start);
+  }
+  /**
+   * Convenience method: scan and return only safe documents.
+   *
+   * @param documents - Array of documents to scan.
+   * @param options - Scan options including the original query.
+   * @returns Array of documents that passed all safety checks.
+   */
+  async filter(documents, options) {
+    const normalized = _RAGuard.normalizeDocuments(documents);
+    const result = await this.scan(normalized, options);
+    const flaggedSet = new Set(result.flaggedDocuments);
+    return normalized.filter((_, i) => !flaggedSet.has(i));
+  }
+  scanLocal(documents, query, startTime) {
+    const embeddings = encodeTexts(documents.map((d) => d.content));
+    const queryEmbedding = query ? encodeTexts([query]) : void 0;
+    const detectorResults = {};
+    const allFlagged = /* @__PURE__ */ new Set();
+    for (const detector of this.detectors) {
+      const result = detector.detect(documents, {
+        query,
+        embeddings,
+        queryEmbedding
+      });
+      detectorResults[detector.name] = result;
+      for (const idx of result.flaggedIndices) {
+        allFlagged.add(idx);
+      }
+    }
+    const riskScores = Object.values(detectorResults).map((r) => r.riskScore);
+    const overallRisk = riskScores.length > 0 ? Math.max(...riskScores) : 0;
+    let recommendation;
+    if (overallRisk >= this.config.riskThreshold) {
+      recommendation = "block" /* BLOCK */;
+    } else if (overallRisk >= this.config.warningThreshold) {
+      recommendation = "cite_with_warning" /* CITE_WITH_WARNING */;
+    } else {
+      recommendation = "proceed" /* PROCEED */;
+    }
+    const latencyMs = performance.now() - startTime;
+    return {
+      safe: overallRisk < this.config.warningThreshold,
+      overallRiskScore: Math.round(overallRisk * 1e4) / 1e4,
+      recommendation,
+      flaggedDocuments: Array.from(allFlagged).sort((a, b) => a - b),
+      detectors: detectorResults,
+      scanId: randomId() + randomId(),
+      latencyMs: Math.round(latencyMs * 100) / 100,
+      documentsScanned: documents.length
+    };
+  }
+  /**
+   * Normalize various input formats into Document objects.
+   */
+  static normalizeDocuments(documents) {
+    return documents.map((doc) => {
+      if (doc instanceof Document) return doc;
+      if (typeof doc === "string") return new Document(doc);
+      if (typeof doc === "object" && doc !== null) {
+        if ("content" in doc) {
+          return new Document(doc);
+        }
+        if ("page_content" in doc) {
+          return new Document({
+            content: doc.page_content,
+            metadata: doc.metadata
+          });
+        }
+        throw new Error(
+          `Object must have 'content' or 'page_content' key: ${JSON.stringify(doc)}`
+        );
+      }
+      throw new TypeError(`Unsupported document type: ${typeof doc}`);
+    });
+  }
+};
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+exports.DEFAULT_CONFIG = DEFAULT_CONFIG;
+exports.Document = Document;
+exports.RAGuard = RAGuard;
+exports.Recommendation = Recommendation;
+exports.VERSION = VERSION;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map