@timmeck/brain 1.8.5 → 2.0.0

package/src/learning/learning-engine.ts

@@ -1,170 +0,0 @@
-import type { LearningConfig } from '../types/config.types.js';
-import type { ErrorRepository } from '../db/repositories/error.repository.js';
-import type { SolutionRepository } from '../db/repositories/solution.repository.js';
-import type { RuleRepository } from '../db/repositories/rule.repository.js';
-import type { AntipatternRepository } from '../db/repositories/antipattern.repository.js';
-import type { SynapseManager } from '../synapses/synapse-manager.js';
-import { extractPatterns } from './pattern-extractor.js';
-import { generateRules, persistRules } from './rule-generator.js';
-import { shouldPruneRule } from './decay.js';
-import { computeAdaptiveThresholds, type AdaptiveThresholds } from './confidence-scorer.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface LearningCycleResult {
-  newPatterns: number;
-  updatedRules: number;
-  prunedRules: number;
-  newAntipatterns: number;
-  duration: number;
-}
-
-export class LearningEngine {
-  private timer: ReturnType<typeof setInterval> | null = null;
-  private logger = getLogger();
-  private lastCycleAt: string | null = null;
-
-  constructor(
-    private config: LearningConfig,
-    private errorRepo: ErrorRepository,
-    private solutionRepo: SolutionRepository,
-    private ruleRepo: RuleRepository,
-    private antipatternRepo: AntipatternRepository,
-    private synapseManager: SynapseManager,
-  ) {}
-
-  start(): void {
-    this.logger.info(`Learning engine starting (interval: ${this.config.intervalMs}ms)`);
-    this.timer = setInterval(() => this.runCycle(), this.config.intervalMs);
-  }
-
-  stop(): void {
-    if (this.timer) {
-      clearInterval(this.timer);
-      this.timer = null;
-    }
-    this.logger.info('Learning engine stopped');
-  }
-
-  runCycle(): LearningCycleResult {
-    const start = Date.now();
-    this.logger.info('Learning cycle starting');
-
-    const result: LearningCycleResult = {
-      newPatterns: 0,
-      updatedRules: 0,
-      prunedRules: 0,
-      newAntipatterns: 0,
-      duration: 0,
-    };
-
-    // Phase 0: Compute adaptive thresholds
-    const totalErrors = this.errorRepo.findUnresolved().length + this.errorRepo.countSince(new Date(0).toISOString());
-    const totalSolutions = this.solutionRepo.getAll().length;
-    const adaptive = computeAdaptiveThresholds(totalErrors, totalSolutions, this.config);
-    this.logger.debug(`Adaptive thresholds: minOcc=${adaptive.minOccurrences}, minSuccess=${adaptive.minSuccessRate.toFixed(2)}, minConf=${adaptive.minConfidence.toFixed(2)}`);
-
-    // Phase 1: Collect recent errors
-    const since = this.lastCycleAt ?? new Date(Date.now() - this.config.intervalMs).toISOString();
-    const recentErrors = this.errorRepo.findUnresolved();
-
-    // Phase 2: Extract patterns
-    const patterns = extractPatterns(recentErrors, adaptive.minSuccessRate);
-    result.newPatterns = patterns.length;
-
-    // Phase 3: Enrich patterns with solution data
-    for (const pattern of patterns) {
-      let totalSuccess = 0;
-      let totalAttempts = 0;
-
-      for (const errorId of pattern.errorIds) {
-        const solutions = this.solutionRepo.findForError(errorId);
-        pattern.solutionIds.push(...solutions.map(s => s.id));
-
-        for (const sol of solutions) {
-          const rate = this.solutionRepo.successRate(sol.id);
-          totalSuccess += rate;
-          totalAttempts++;
-        }
-      }
-
-      pattern.successRate = totalAttempts > 0 ? totalSuccess / totalAttempts : 0;
-      pattern.confidence = Math.min(
-        0.95,
-        pattern.successRate * 0.6 + Math.min(1, pattern.occurrences / 10) * 0.4,
-      );
-    }
-
-    // Phase 4: Generate rules from patterns (using adaptive thresholds)
-    const adaptiveConfig = { ...this.config, ...adaptive };
-    const rules = generateRules(patterns, adaptiveConfig);
-    result.updatedRules = persistRules(rules, this.ruleRepo);
-
-    // Phase 5: Prune weak rules (using adaptive thresholds)
-    const activeRules = this.ruleRepo.findActive();
-    for (const rule of activeRules) {
-      if (shouldPruneRule(
-        rule.confidence,
-        0, // rejection count not tracked yet
-        rule.occurrences,
-        adaptive.pruneThreshold,
-        this.config.maxRejectionRate,
-      )) {
-        this.ruleRepo.update(rule.id, { active: 0 });
-        result.prunedRules++;
-      }
-    }
-
-    // Phase 6: Detect antipatterns
-    result.newAntipatterns = this.detectAntipatterns();
-
-    // Phase 7: Run synapse decay
-    this.synapseManager.runDecay();
-
-    this.lastCycleAt = new Date().toISOString();
-    result.duration = Date.now() - start;
-    this.logger.info(`Learning cycle complete: ${result.newPatterns} patterns, ${result.updatedRules} rules, ${result.prunedRules} pruned, ${result.newAntipatterns} antipatterns (${result.duration}ms)`);
-
-    return result;
-  }
-
-  private detectAntipatterns(): number {
-    const unresolvedErrors = this.errorRepo.findUnresolved();
-    const recurring = unresolvedErrors.filter(e => e.occurrence_count >= this.config.minOccurrences);
-    let count = 0;
-
-    for (const error of recurring) {
-      const solutions = this.solutionRepo.findForError(error.id);
-      const allFailed = solutions.length > 0 && solutions.every(s => {
-        const rate = this.solutionRepo.successRate(s.id);
-        return rate < 0.3;
-      });
-
-      if (solutions.length >= 2 && allFailed) {
-        // Check if antipattern already exists
-        const existing = this.antipatternRepo.findByProject(error.project_id);
-        const alreadyDetected = existing.some(ap =>
-          ap.pattern.includes(error.type) && ap.description.includes(error.message.substring(0, 30))
-        );
-
-        if (!alreadyDetected) {
-          this.antipatternRepo.create({
-            pattern: `${error.type}.*${error.message.substring(0, 40).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}`,
-            description: `Recurring error without solution: ${error.type}: ${error.message}`,
-            severity: solutions.length >= 4 ? 'critical' : 'warning',
-            suggestion: null,
-            occurrences: error.occurrence_count,
-            project_id: error.project_id,
-            global: 0,
-          });
-          count++;
-        }
-      }
-    }
-
-    return count;
-  }
-
-  getLastCycleAt(): string | null {
-    return this.lastCycleAt;
-  }
-}

package/src/learning/pattern-extractor.ts

@@ -1,90 +0,0 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import { tokenize } from '../matching/tokenizer.js';
-import { cosineSimilarity } from '../matching/similarity.js';
-
-export interface ErrorPattern {
-  errorType: string;
-  messageTemplate: string;
-  messageRegex: string;
-  filePattern: string | null;
-  occurrences: number;
-  errorIds: number[];
-  solutionIds: number[];
-  confidence: number;
-  successRate: number;
-}
-
-interface Centroid {
-  errorType: string;
-  tokens: string[];
-  errorIds: number[];
-  filePattern: string | null;
-}
-
-/**
- * Extract patterns from error records using centroid-based clustering.
- */
-export function extractPatterns(
-  errors: ErrorRecord[],
-  similarityThreshold: number = 0.7,
-): ErrorPattern[] {
-  const centroids: Centroid[] = [];
-
-  for (const error of errors) {
-    const tokens = tokenize(`${error.type} ${error.message}`);
-    let merged = false;
-
-    for (const centroid of centroids) {
-      if (centroid.errorType !== error.type) continue;
-
-      const sim = cosineSimilarity(centroid.tokens, tokens);
-      if (sim >= similarityThreshold) {
-        // Merge into existing centroid (running average)
-        const allTokens = [...centroid.tokens, ...tokens];
-        centroid.tokens = [...new Set(allTokens)];
-        centroid.errorIds.push(error.id);
-        if (!centroid.filePattern && error.file_path) {
-          centroid.filePattern = extractFilePattern(error.file_path);
-        }
-        merged = true;
-        break;
-      }
-    }
-
-    if (!merged) {
-      centroids.push({
-        errorType: error.type,
-        tokens,
-        errorIds: [error.id],
-        filePattern: error.file_path ? extractFilePattern(error.file_path) : null,
-      });
-    }
-  }
-
-  return centroids
-    .filter(c => c.errorIds.length >= 2)
-    .map(c => ({
-      errorType: c.errorType,
-      messageTemplate: c.tokens.join(' '),
-      messageRegex: buildRegex(c.tokens),
-      filePattern: c.filePattern,
-      occurrences: c.errorIds.length,
-      errorIds: c.errorIds,
-      solutionIds: [],
-      confidence: 0,
-      successRate: 0,
-    }));
-}
-
-function extractFilePattern(filePath: string): string {
-  // Extract the meaningful part: last directory + extension
-  const parts = filePath.replace(/\\/g, '/').split('/');
-  const fileName = parts[parts.length - 1] ?? '';
-  const ext = fileName.split('.').pop() ?? '';
-  return ext ? `*.${ext}` : '*';
-}
-
-function buildRegex(tokens: string[]): string {
-  const escaped = tokens.map(t => t.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
-  return escaped.join('.*');
-}

package/src/learning/rule-generator.ts

@@ -1,74 +0,0 @@
-import type { LearningConfig } from '../types/config.types.js';
-import type { RuleRepository } from '../db/repositories/rule.repository.js';
-import type { ErrorPattern } from './pattern-extractor.js';
-import { getLogger } from '../utils/logger.js';
-
-export interface GeneratedRule {
-  pattern: string;
-  action: string;
-  description: string;
-  confidence: number;
-  sourceErrorIds: number[];
-}
-
-/**
- * Generate prevention rules from extracted patterns.
- */
-export function generateRules(
-  patterns: ErrorPattern[],
-  config: LearningConfig,
-): GeneratedRule[] {
-  return patterns
-    .filter(p =>
-      p.occurrences >= config.minOccurrences &&
-      p.confidence >= config.minConfidence,
-    )
-    .map(pattern => ({
-      pattern: pattern.messageRegex,
-      action: pattern.confidence >= 0.90
-        ? `Auto-fix available for ${pattern.errorType}`
-        : `Suggestion: check ${pattern.errorType} pattern (${pattern.occurrences} occurrences)`,
-      description: `Auto-generated from ${pattern.occurrences} occurrences of ${pattern.errorType}`,
-      confidence: pattern.confidence,
-      sourceErrorIds: pattern.errorIds,
-    }));
-}
-
-/**
- * Persist generated rules to the database.
- */
-export function persistRules(
-  rules: GeneratedRule[],
-  ruleRepo: RuleRepository,
-  projectId?: number,
-): number {
-  const logger = getLogger();
-  let created = 0;
-
-  for (const rule of rules) {
-    // Check if similar rule already exists
-    const existing = ruleRepo.findByPattern(rule.pattern);
-    if (existing.length > 0) {
-      // Update confidence of existing rule
-      const best = existing[0]!;
-      if (rule.confidence > best.confidence) {
-        ruleRepo.update(best.id, { confidence: rule.confidence });
-      }
-      continue;
-    }
-
-    ruleRepo.create({
-      pattern: rule.pattern,
-      action: rule.action,
-      description: rule.description,
-      confidence: rule.confidence,
-      occurrences: 0,
-      active: 1,
-      project_id: projectId ?? null,
-    });
-    created++;
-    logger.info(`New rule generated: ${rule.pattern.substring(0, 50)}...`);
-  }
-
-  return created;
-}

package/src/matching/error-matcher.ts

@@ -1,166 +0,0 @@
-import type { ErrorRecord } from '../types/error.types.js';
-import { tokenize } from './tokenizer.js';
-import { cosineSimilarity, jaccardSimilarity, levenshteinDistance } from './similarity.js';
-
-export interface SignalScore {
-  signal: string;
-  score: number;
-  weighted: number;
-}
-
-export interface MatchResult {
-  errorId: number;
-  score: number;
-  signals: SignalScore[];
-  isStrong: boolean;
-}
-
-interface MatchSignal {
-  name: string;
-  weight: number;
-  compute: (a: ErrorRecord, b: ErrorRecord) => number;
-}
-
-// Base signals (used when vector search is NOT available)
-const SIGNALS_BASE: MatchSignal[] = [
-  { name: 'fingerprint', weight: 0.20, compute: fingerprintMatch },
-  { name: 'message_similarity', weight: 0.25, compute: messageSimilarity },
-  { name: 'type_match', weight: 0.15, compute: typeMatch },
-  { name: 'stack_similarity', weight: 0.15, compute: stackSimilarity },
-  { name: 'file_similarity', weight: 0.12, compute: fileSimilarity },
-  { name: 'context_similarity', weight: 0.13, compute: contextSimilarity },
-];
-
-// Hybrid signals (used when vector search IS available — vector gets 20% weight)
-const SIGNALS_HYBRID: MatchSignal[] = [
-  { name: 'fingerprint', weight: 0.25, compute: fingerprintMatch },
-  { name: 'message_similarity', weight: 0.15, compute: messageSimilarity },
-  { name: 'type_match', weight: 0.12, compute: typeMatch },
-  { name: 'stack_similarity', weight: 0.12, compute: stackSimilarity },
-  { name: 'file_similarity', weight: 0.08, compute: fileSimilarity },
-  { name: 'context_similarity', weight: 0.08, compute: contextSimilarity },
-];
-
-const VECTOR_WEIGHT = 0.20;
-const MATCH_THRESHOLD = 0.55;
-const STRONG_MATCH_THRESHOLD = 0.90;
-
-/**
- * Hybrid error matching: TF-IDF signals + optional vector similarity + synapse boost.
- *
- * @param incoming - The error to match
- * @param candidates - Candidate errors to compare against
- * @param vectorScores - Pre-computed vector similarity scores (errorId → score)
- * @param synapseScores - Pre-computed synapse proximity scores (errorId → score)
- */
-export function matchError(
-  incoming: ErrorRecord,
-  candidates: ErrorRecord[],
-  vectorScores?: Map<number, number>,
-  synapseScores?: Map<number, number>,
-): MatchResult[] {
-  const useHybrid = vectorScores && vectorScores.size > 0;
-  const useSynapse = synapseScores && synapseScores.size > 0;
-  const signals = useHybrid ? SIGNALS_HYBRID : SIGNALS_BASE;
-
-  return candidates
-    .map(candidate => {
-      const signalResults = signals.map(signal => {
-        const score = signal.compute(incoming, candidate);
-        return {
-          signal: signal.name,
-          score,
-          weighted: score * signal.weight,
-        };
-      });
-
-      // Add vector similarity signal (if available)
-      if (useHybrid) {
-        const vectorScore = vectorScores.get(candidate.id) ?? 0;
-        signalResults.push({
-          signal: 'vector_similarity',
-          score: vectorScore,
-          weighted: vectorScore * VECTOR_WEIGHT,
-        });
-      }
-
-      let totalScore = signalResults.reduce((sum, s) => sum + s.weighted, 0);
-
-      // Synapse boost: if errors are already connected in the synapse network,
-      // give up to 5% bonus (doesn't create false positives, only reinforces)
-      if (useSynapse) {
-        const synapseScore = synapseScores.get(candidate.id) ?? 0;
-        if (synapseScore > 0) {
-          const bonus = Math.min(synapseScore * 0.05, 0.05);
-          totalScore = Math.min(1.0, totalScore + bonus);
-          signalResults.push({
-            signal: 'synapse_boost',
-            score: synapseScore,
-            weighted: bonus,
-          });
-        }
-      }
-
-      return {
-        errorId: candidate.id,
-        score: totalScore,
-        signals: signalResults,
-        isStrong: totalScore >= STRONG_MATCH_THRESHOLD,
-      };
-    })
-    .filter(result => result.score >= MATCH_THRESHOLD)
-    .sort((a, b) => b.score - a.score);
-}
-
-function fingerprintMatch(a: ErrorRecord, b: ErrorRecord): number {
-  return a.fingerprint === b.fingerprint ? 1.0 : 0.0;
-}
-
-function messageSimilarity(a: ErrorRecord, b: ErrorRecord): number {
-  const tokensA = tokenize(a.message);
-  const tokensB = tokenize(b.message);
-  return cosineSimilarity(tokensA, tokensB);
-}
-
-function typeMatch(a: ErrorRecord, b: ErrorRecord): number {
-  return a.type === b.type ? 1.0 : 0.0;
-}
-
-function stackSimilarity(a: ErrorRecord, b: ErrorRecord): number {
-  const rawA = a.raw_output ?? '';
-  const rawB = b.raw_output ?? '';
-
-  const frameRe = /at (?:(.+?) )?\(/g;
-  const extractFuncs = (raw: string) => {
-    const funcs: string[] = [];
-    let m: RegExpExecArray | null;
-    const re = new RegExp(frameRe.source, 'g');
-    while ((m = re.exec(raw)) !== null) {
-      if (m[1]) funcs.push(m[1]);
-    }
-    return funcs;
-  };
-
-  const funcsA = extractFuncs(rawA);
-  const funcsB = extractFuncs(rawB);
-
-  if (funcsA.length === 0 && funcsB.length === 0) return 0.5;
-  return jaccardSimilarity(funcsA, funcsB);
-}
-
-function fileSimilarity(a: ErrorRecord, b: ErrorRecord): number {
-  const pathA = a.file_path ?? '';
-  const pathB = b.file_path ?? '';
-  if (!pathA || !pathB) return 0.0;
-  if (pathA === pathB) return 1.0;
-  return levenshteinDistance(pathA, pathB);
-}
-
-function contextSimilarity(a: ErrorRecord, b: ErrorRecord): number {
-  const ctxA = a.context ?? '';
-  const ctxB = b.context ?? '';
-  if (!ctxA || !ctxB) return 0.0;
-  const tokensA = tokenize(ctxA);
-  const tokensB = tokenize(ctxB);
-  return cosineSimilarity(tokensA, tokensB);
-}

package/src/matching/fingerprint.ts

@@ -1,34 +0,0 @@
-import path from 'node:path';
-import { sha256 } from '../utils/hash.js';
-import type { StackFrame } from '../parsing/types.js';
-
-export function templateMessage(msg: string): string {
-  return msg
-    .replace(/[A-Z]:\\[\w\-.\\ ]+\.\w+/g, '<PATH>')
-    .replace(/\/[\w\-./ ]+\.\w+/g, '<PATH>')
-    .replace(/:(\d+):(\d+)/g, ':<LINE>:<COL>')
-    .replace(/line \d+/gi, 'line <LINE>')
-    .replace(/0x[0-9a-fA-F]+/g, '<ADDR>')
-    .replace(/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi, '<UUID>')
-    .replace(/https?:\/\/[^\s]+/g, '<URL>')
-    .replace(/\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}:\d{2}/g, '<TIMESTAMP>')
-    // Normalize JS/TS property access patterns so "reading 'map'" ≈ "reading 'forEach'"
-    .replace(/\(reading ['"][^'"]*['"]\)/g, "(reading '<PROP>')")
-    .replace(/\(writing ['"][^'"]*['"]\)/g, "(writing '<PROP>')")
-    // Normalize quoted identifiers (e.g., 'someVar', "someFunc")
-    .replace(/['"][a-zA-Z_$][\w$]*['"]/g, "'<IDENT>'");
-}
-
-export function generateFingerprint(
-  errorType: string,
-  message: string,
-  frames: StackFrame[],
-): string {
-  const template = templateMessage(message);
-  const topFrames = frames
-    .slice(0, 3)
-    .map(f => `${f.function_name || '<anon>'}@${path.basename(f.file_path || '<unknown>')}`)
-    .join('|');
-  const input = `${errorType}::${template}::${topFrames}`;
-  return sha256(input);
-}

package/src/matching/similarity.ts

@@ -1,61 +0,0 @@
-export function levenshteinDistance(a: string, b: string): number {
-  if (a === b) return 1.0;
-  if (a.length === 0 || b.length === 0) return 0.0;
-
-  const dp: number[][] = Array(b.length + 1)
-    .fill(0)
-    .map(() => Array(a.length + 1).fill(0) as number[]);
-
-  for (let i = 0; i <= a.length; i++) dp[0]![i] = i;
-  for (let j = 0; j <= b.length; j++) dp[j]![0] = j;
-
-  for (let i = 1; i <= b.length; i++) {
-    for (let j = 1; j <= a.length; j++) {
-      const cost = a[j - 1] === b[i - 1] ? 0 : 1;
-      dp[i]![j] = Math.min(
-        dp[i - 1]![j]! + 1,
-        dp[i]![j - 1]! + 1,
-        dp[i - 1]![j - 1]! + cost,
-      );
-    }
-  }
-
-  return 1 - dp[b.length]![a.length]! / Math.max(a.length, b.length);
-}
-
-export function cosineSimilarity(tokensA: string[], tokensB: string[]): number {
-  if (tokensA.length === 0 || tokensB.length === 0) return 0.0;
-
-  const vocab = new Set([...tokensA, ...tokensB]);
-  const vecA = new Map<string, number>();
-  const vecB = new Map<string, number>();
-
-  for (const t of tokensA) vecA.set(t, (vecA.get(t) ?? 0) + 1);
-  for (const t of tokensB) vecB.set(t, (vecB.get(t) ?? 0) + 1);
-
-  let dot = 0;
-  let magA = 0;
-  let magB = 0;
-
-  for (const word of vocab) {
-    const a = vecA.get(word) ?? 0;
-    const b = vecB.get(word) ?? 0;
-    dot += a * b;
-    magA += a * a;
-    magB += b * b;
-  }
-
-  const denom = Math.sqrt(magA) * Math.sqrt(magB);
-  return denom === 0 ? 0 : dot / denom;
-}
-
-export function jaccardSimilarity(tokensA: string[], tokensB: string[]): number {
-  if (tokensA.length === 0 && tokensB.length === 0) return 0.0;
-
-  const setA = new Set(tokensA);
-  const setB = new Set(tokensB);
-  const intersection = new Set([...setA].filter(x => setB.has(x)));
-  const union = new Set([...setA, ...setB]);
-
-  return union.size === 0 ? 0 : intersection.size / union.size;
-}

package/src/matching/tfidf.ts

@@ -1,74 +0,0 @@
-export class TfIdfIndex {
-  private documents = new Map<number, string[]>();
-  private df = new Map<string, number>();
-  private idf = new Map<string, number>();
-  private documentCount = 0;
-
-  addDocument(id: number, tokens: string[]): void {
-    if (this.documents.has(id)) {
-      this.removeDocument(id);
-    }
-    const unique = new Set(tokens);
-    for (const token of unique) {
-      this.df.set(token, (this.df.get(token) ?? 0) + 1);
-    }
-    this.documents.set(id, tokens);
-    this.documentCount++;
-    this.recomputeIdfForTerms(unique);
-  }
-
-  removeDocument(id: number): void {
-    const tokens = this.documents.get(id);
-    if (!tokens) return;
-
-    const unique = new Set(tokens);
-    for (const token of unique) {
-      const count = this.df.get(token) ?? 0;
-      if (count <= 1) {
-        this.df.delete(token);
-        this.idf.delete(token);
-      } else {
-        this.df.set(token, count - 1);
-      }
-    }
-    this.documents.delete(id);
-    this.documentCount--;
-  }
-
-  query(tokens: string[], topK: number = 10): Array<{ id: number; score: number }> {
-    const scores = new Map<number, number>();
-
-    for (const token of tokens) {
-      const idfVal = this.idf.get(token) ?? 0;
-      if (idfVal === 0) continue;
-
-      for (const [docId, docTokens] of this.documents) {
-        const tf = docTokens.filter(t => t === token).length / docTokens.length;
-        const score = (scores.get(docId) ?? 0) + tf * idfVal;
-        scores.set(docId, score);
-      }
-    }
-
-    return Array.from(scores.entries())
-      .map(([id, score]) => ({ id, score }))
-      .sort((a, b) => b.score - a.score)
-      .slice(0, topK);
-  }
-
-  getDocumentCount(): number {
-    return this.documentCount;
-  }
-
-  getIdf(): ReadonlyMap<string, number> {
-    return this.idf;
-  }
-
-  private recomputeIdfForTerms(terms: Set<string>): void {
-    for (const term of terms) {
-      const dfVal = this.df.get(term) ?? 0;
-      if (dfVal > 0 && this.documentCount > 0) {
-        this.idf.set(term, Math.log(this.documentCount / dfVal));
-      }
-    }
-  }
-}