stellavault 0.1.0 → 0.2.1

package/packages/core/src/indexer/scanner.ts

@@ -1,142 +0,0 @@
-// Design Ref: §6 — Indexer (scanner: glob + frontmatter 파싱)
-
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { join, relative, extname } from 'node:path';
-import { createHash } from 'node:crypto';
-import matter from 'gray-matter';
-import type { Document } from '../types/document.js';
-
-export interface ScanResult {
-  documents: Document[];
-  scannedFiles: number;
-  skippedFiles: number;
-}
-
-/**
- * vault 디렉토리에서 모든 .md 파일을 스캔하여 Document 목록 반환
- */
-export function scanVault(vaultPath: string): ScanResult {
-  const documents: Document[] = [];
-  let skippedFiles = 0;
-
-  const mdFiles = findMdFiles(vaultPath);
-
-  for (const filePath of mdFiles) {
-    try {
-      const doc = parseDocument(vaultPath, filePath);
-      documents.push(doc);
-    } catch {
-      skippedFiles++;
-    }
-  }
-
-  return { documents, scannedFiles: mdFiles.length, skippedFiles };
-}
-
-function findMdFiles(dir: string, files: string[] = []): string[] {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join(dir, entry.name);
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'zh-CN') continue;
-      findMdFiles(fullPath, files);
-    } else if (extname(entry.name) === '.md') {
-      files.push(fullPath);
-    }
-  }
-  return files;
-}
-
-function parseDocument(vaultPath: string, filePath: string): Document {
-  const raw = readFileSync(filePath, 'utf-8');
-  const stat = statSync(filePath);
-  const { data: frontmatter, content } = matter(raw);
-
-  const relativePath = relative(vaultPath, filePath).replace(/\\/g, '/');
-  const id = createHash('sha256').update(relativePath).digest('hex').slice(0, 16);
-  const contentHash = createHash('sha256').update(raw).digest('hex').slice(0, 16);
-
-  const title = (frontmatter.title as string)
-    ?? extractFirstHeading(content)
-    ?? relativePath.replace(/\.md$/, '');
-
-  const tags = extractTags(frontmatter, content);
-
-  // source/type 자동 추출 (원본 파일 수정 없이 DB에만 저장)
-  const source = inferSource(frontmatter, relativePath);
-  const type = inferType(frontmatter, relativePath);
-
-  return {
-    id,
-    filePath: relativePath,
-    title,
-    content,
-    frontmatter,
-    tags,
-    lastModified: stat.mtime.toISOString(),
-    contentHash,
-    source,
-    type,
-  };
-}
-
-function inferSource(frontmatter: Record<string, unknown>, filePath: string): string {
-  // frontmatter에 명시된 경우
-  if (frontmatter.source && typeof frontmatter.source === 'string') {
-    if (frontmatter.source.startsWith('http')) return 'clip';
-    return frontmatter.source;
-  }
-  // 경로 기반 추론
-  if (filePath.includes('clips/') || filePath.includes('clip/')) return 'clip';
-  if (filePath.includes('PDCA') || filePath.includes('pdca')) return 'local';
-  if (frontmatter['x-i18n']) return 'notion'; // Notion 번역 문서
-  if (frontmatter.clipped) return 'clip';
-  return 'local';
-}
-
-function inferType(frontmatter: Record<string, unknown>, filePath: string): string {
-  // frontmatter에 명시된 경우
-  if (frontmatter.type && typeof frontmatter.type === 'string') return frontmatter.type;
-  // tags 기반
-  const tags = Array.isArray(frontmatter.tags) ? frontmatter.tags : [];
-  if (tags.includes('bridge') || tags.includes('auto-generated')) return 'bridge';
-  if (tags.includes('clip') || tags.includes('youtube')) return 'clip';
-  if (tags.includes('decision')) return 'decision';
-  // 경로 기반
-  if (filePath.includes('clips/')) return 'clip';
-  if (filePath.includes('Decisions/') || filePath.includes('decisions/')) return 'decision';
-  if (filePath.includes('Sessions/') || filePath.includes('sessions/')) return 'session';
-  if (filePath.includes('Research/')) return 'research';
-  if (filePath.includes('Lessons/')) return 'lesson';
-  if (filePath.includes('Templates/')) return 'template';
-  return 'note';
-}
-
-function extractFirstHeading(content: string): string | null {
-  const match = content.match(/^#\s+(.+)$/m);
-  return match ? match[1].trim() : null;
-}
-
-function extractTags(frontmatter: Record<string, unknown>, content: string): string[] {
-  const tags = new Set<string>();
-
-  // frontmatter tags
-  const fmTags = frontmatter.tags;
-  if (Array.isArray(fmTags)) {
-    fmTags.forEach(t => tags.add(String(t)));
-  } else if (typeof fmTags === 'string') {
-    fmTags.split(',').map(t => t.trim()).filter(Boolean).forEach(t => tags.add(t));
-  }
-
-  // inline #tags (CSS 컬러코드, 순수 숫자, heading # 제외)
-  const inlineTags = content.match(/(?:^|\s)#([a-zA-Z가-힣][a-zA-Z가-힣\w-]*)/g);
-  if (inlineTags) {
-    for (const raw of inlineTags) {
-      const tag = raw.trim().slice(1);
-      // CSS hex 컬러 (#fff, #6c5ce7 등) 제외
-      if (/^[0-9a-fA-F]{3,8}$/.test(tag)) continue;
-      tags.add(tag);
-    }
-  }
-
-  return [...tags];
-}

package/packages/core/src/indexer/watcher.ts

@@ -1,62 +0,0 @@
-// Design Ref: §6.3 — 파일 감시 + 증분 인덱싱 (debounce 5s)
-
-import { watch, type FSWatcher } from 'chokidar';
-import { extname } from 'node:path';
-import type { Embedder } from './embedder.js';
-import type { VectorStore } from '../store/types.js';
-import { indexVault } from './index.js';
-import type { ChunkOptions } from './chunker.js';
-
-export interface WatcherOptions {
-  vaultPath: string;
-  store: VectorStore;
-  embedder: Embedder;
-  chunkOptions?: Partial<ChunkOptions>;
-  debounceMs?: number;
-  onReindex?: (result: { indexed: number; skipped: number }) => void;
-}
-
-export function createWatcher(options: WatcherOptions): { start(): void; stop(): void } {
-  const { vaultPath, store, embedder, chunkOptions, debounceMs = 5000, onReindex } = options;
-  let watcher: FSWatcher | null = null;
-  let debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  let reindexing = false;
-
-  async function triggerReindex() {
-    if (reindexing) return;
-    reindexing = true;
-    try {
-      const result = await indexVault(vaultPath, { store, embedder, chunkOptions });
-      onReindex?.({ indexed: result.indexed, skipped: result.skipped });
-    } finally {
-      reindexing = false;
-    }
-  }
-
-  function scheduleReindex() {
-    if (debounceTimer) clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(() => triggerReindex(), debounceMs);
-  }
-
-  return {
-    start() {
-      watcher = watch(vaultPath, {
-        ignored: /(^|[\/\\])\.|node_modules/,
-        persistent: true,
-        ignoreInitial: true,
-      });
-
-      watcher.on('all', (event, path) => {
-        if (extname(path) !== '.md') return;
-        if (['add', 'change', 'unlink'].includes(event)) {
-          scheduleReindex();
-        }
-      });
-    },
-
-    stop() {
-      if (debounceTimer) clearTimeout(debounceTimer);
-      watcher?.close();
-    },
-  };
-}

package/packages/core/src/intelligence/contradiction-detector.ts

@@ -1,134 +0,0 @@
-// Contradiction Detector (F-A12)
-// Finds potentially contradicting statements across notes
-// Uses embedding similarity + negation pattern detection
-
-import type { VectorStore } from '../store/types.js';
-
-export interface ContradictionPair {
-  docA: { id: string; title: string; filePath: string; statement: string };
-  docB: { id: string; title: string; filePath: string; statement: string };
-  similarity: number;
-  confidence: number; // 0-1, how likely this is a real contradiction
-  type: 'negation' | 'value_conflict' | 'temporal' | 'semantic';
-}
-
-// Negation/opposition patterns
-const NEGATION_PAIRS = [
-  ['should', 'should not'], ['must', 'must not'], ['always', 'never'],
-  ['best', 'worst'], ['good', 'bad'], ['correct', 'incorrect'],
-  ['true', 'false'], ['increase', 'decrease'], ['enable', 'disable'],
-  ['recommended', 'not recommended'], ['use', 'avoid'],
-  ['prefer', 'avoid'], ['do', "don't"], ['is', "isn't"],
-  ['can', "can't"], ['will', "won't"], ['important', 'unimportant'],
-  ['필요', '불필요'], ['해야', '하면 안'], ['좋', '나쁜'], ['맞', '틀'],
-];
-
-function extractKeyStatements(content: string): string[] {
-  return content
-    .split(/[.\n!?]/)
-    .map(s => s.trim())
-    .filter(s => s.length > 20 && s.length < 200)
-    .filter(s => {
-      const lower = s.toLowerCase();
-      return /should|must|always|never|best|important|recommend|prefer|avoid|필요|해야|좋|나쁜/.test(lower);
-    })
-    .slice(0, 10); // max 10 statements per document
-}
-
-function detectNegationConflict(stmtA: string, stmtB: string): { isConflict: boolean; confidence: number; type: ContradictionPair['type'] } {
-  const a = stmtA.toLowerCase();
-  const b = stmtB.toLowerCase();
-
-  // Check negation pairs
-  for (const [pos, neg] of NEGATION_PAIRS) {
-    if ((a.includes(pos) && b.includes(neg)) || (a.includes(neg) && b.includes(pos))) {
-      // Check if they're talking about the same subject (share words)
-      const wordsA = new Set(a.split(/\s+/).filter(w => w.length > 3));
-      const wordsB = new Set(b.split(/\s+/).filter(w => w.length > 3));
-      const overlap = [...wordsA].filter(w => wordsB.has(w)).length;
-      const minSize = Math.min(wordsA.size, wordsB.size) || 1;
-      const subjectOverlap = overlap / minSize;
-
-      if (subjectOverlap > 0.2) {
-        return { isConflict: true, confidence: Math.min(0.5 + subjectOverlap * 0.5, 0.95), type: 'negation' };
-      }
-    }
-  }
-
-  // Check numeric value conflicts (e.g., "timeout should be 30s" vs "timeout should be 5s")
-  const numsA = a.match(/\d+/g);
-  const numsB = b.match(/\d+/g);
-  if (numsA && numsB) {
-    const wordsA = new Set(a.replace(/\d+/g, '').split(/\s+/).filter(w => w.length > 3));
-    const wordsB = new Set(b.replace(/\d+/g, '').split(/\s+/).filter(w => w.length > 3));
-    const overlap = [...wordsA].filter(w => wordsB.has(w)).length;
-    if (overlap >= 2 && numsA[0] !== numsB[0]) {
-      return { isConflict: true, confidence: 0.6, type: 'value_conflict' };
-    }
-  }
-
-  return { isConflict: false, confidence: 0, type: 'semantic' };
-}
-
-export async function detectContradictions(
-  store: VectorStore,
-  limit = 20,
-): Promise<ContradictionPair[]> {
-  const docs = await store.getAllDocuments();
-  const embeddings = await store.getDocumentEmbeddings();
-
-  if (docs.length < 2) return [];
-
-  // Build document vectors + key statements
-  const docData = new Map<string, { vec: number[]; title: string; filePath: string; statements: string[] }>();
-  for (const doc of docs) {
-    const vec = embeddings.get(doc.id);
-    if (!vec) continue;
-    const statements = extractKeyStatements(doc.content);
-    if (statements.length === 0) continue;
-    docData.set(doc.id, { vec: Array.from(vec), title: doc.title, filePath: doc.filePath, statements });
-  }
-
-  const ids = [...docData.keys()];
-  const results: ContradictionPair[] = [];
-
-  // Compare documents with moderate similarity (same topic, possibly conflicting)
-  for (let i = 0; i < ids.length && results.length < limit * 3; i++) {
-    for (let j = i + 1; j < ids.length && results.length < limit * 3; j++) {
-      const a = docData.get(ids[i])!;
-      const b = docData.get(ids[j])!;
-      const sim = cosineSim(a.vec, b.vec);
-
-      // Sweet spot: similar enough to be same topic, not identical
-      if (sim < 0.3 || sim > 0.9) continue;
-
-      // Compare statements
-      for (const stmtA of a.statements) {
-        for (const stmtB of b.statements) {
-          const { isConflict, confidence, type } = detectNegationConflict(stmtA, stmtB);
-          if (isConflict && confidence >= 0.5) {
-            results.push({
-              docA: { id: ids[i], title: a.title, filePath: a.filePath, statement: stmtA },
-              docB: { id: ids[j], title: b.title, filePath: b.filePath, statement: stmtB },
-              similarity: Math.round(sim * 1000) / 1000,
-              confidence: Math.round(confidence * 100) / 100,
-              type,
-            });
-          }
-        }
-      }
-    }
-  }
-
-  return results
-    .sort((a, b) => b.confidence - a.confidence)
-    .slice(0, limit);
-}
-
-function cosineSim(a: number[], b: number[]): number {
-  if (a.length !== b.length) return 0;
-  let dot = 0, na = 0, nb = 0;
-  for (let i = 0; i < a.length; i++) { dot += a[i] * b[i]; na += a[i] * a[i]; nb += b[i] * b[i]; }
-  const d = Math.sqrt(na) * Math.sqrt(nb);
-  return d === 0 ? 0 : dot / d;
-}

package/packages/core/src/intelligence/decay-engine.ts

@@ -1,229 +0,0 @@
-// Design Ref: §3.2 — 감쇠 엔진 (DB 연동)
-// Plan SC: SC-01, SC-02, SC-04
-
-import type { Database } from 'better-sqlite3';
-import type { DecayState, AccessEvent, DecayReport } from './types.js';
-import {
-  computeRetrievability,
-  updateStability,
-  estimateInitialStability,
-  elapsedDays,
-  FSRS_PARAMS,
-} from './fsrs.js';
-
-export class DecayEngine {
-  constructor(private db: Database) {
-    this.ensureTables();
-  }
-
-  private ensureTables() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS access_log (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        document_id TEXT NOT NULL,
-        access_type TEXT NOT NULL,
-        accessed_at TEXT NOT NULL
-      );
-      CREATE INDEX IF NOT EXISTS idx_access_log_doc ON access_log(document_id);
-      CREATE INDEX IF NOT EXISTS idx_access_log_time ON access_log(accessed_at);
-
-      CREATE TABLE IF NOT EXISTS decay_state (
-        document_id TEXT PRIMARY KEY,
-        stability REAL NOT NULL DEFAULT 7.0,
-        difficulty REAL NOT NULL DEFAULT 5.0,
-        last_access TEXT NOT NULL,
-        retrievability REAL NOT NULL DEFAULT 1.0,
-        updated_at TEXT NOT NULL
-      );
-    `);
-  }
-
-  /**
-   * Record an access event and update decay state.
-   */
-  async recordAccess(event: AccessEvent): Promise<void> {
-    const now = event.timestamp || new Date().toISOString();
-
-    // Log the event
-    this.db.prepare(
-      'INSERT INTO access_log (document_id, access_type, accessed_at) VALUES (?, ?, ?)'
-    ).run(event.documentId, event.type, now);
-
-    // Get or create decay state
-    const existing = this.db.prepare(
-      'SELECT * FROM decay_state WHERE document_id = ?'
-    ).get(event.documentId) as any;
-
-    if (existing) {
-      const elapsed = elapsedDays(existing.last_access, now);
-      const currentR = computeRetrievability(existing.stability, elapsed);
-      const newS = updateStability(existing.stability, existing.difficulty, currentR);
-
-      this.db.prepare(`
-        UPDATE decay_state SET stability = ?, last_access = ?, retrievability = 1.0, updated_at = ?
-        WHERE document_id = ?
-      `).run(newS, now, now, event.documentId);
-    } else {
-      // New document — estimate initial stability
-      const doc = this.db.prepare('SELECT content FROM documents WHERE id = ?').get(event.documentId) as any;
-      const contentLen = doc?.content?.length ?? 500;
-      const connCount = (this.db.prepare(
-        'SELECT COUNT(*) as c FROM chunks WHERE document_id = ?'
-      ).get(event.documentId) as any)?.c ?? 1;
-      const initS = estimateInitialStability(contentLen, connCount);
-
-      this.db.prepare(`
-        INSERT INTO decay_state (document_id, stability, difficulty, last_access, retrievability, updated_at)
-        VALUES (?, ?, ?, ?, 1.0, ?)
-      `).run(event.documentId, initS, FSRS_PARAMS.difficulty, now, now);
-    }
-  }
-
-  /**
-   * Batch compute retrievability for all documents.
-   */
-  async computeAll(): Promise<DecayReport> {
-    const now = new Date().toISOString();
-
-    // Initialize documents that don't have decay state yet
-    await this.initializeNewDocuments();
-
-    // Compute R for all
-    const states = this.db.prepare('SELECT * FROM decay_state').all() as any[];
-    const docs = this.db.prepare('SELECT id, title FROM documents').all() as any[];
-    const titleMap = new Map(docs.map((d: any) => [d.id, d.title]));
-
-    const updated: DecayState[] = [];
-    const updateStmt = this.db.prepare(
-      'UPDATE decay_state SET retrievability = ?, updated_at = ? WHERE document_id = ?'
-    );
-
-    const tx = this.db.transaction(() => {
-      for (const s of states) {
-        const elapsed = elapsedDays(s.last_access, now);
-        const r = computeRetrievability(s.stability, elapsed);
-        updateStmt.run(r, now, s.document_id);
-        updated.push({
-          documentId: s.document_id,
-          stability: s.stability,
-          difficulty: s.difficulty,
-          lastAccess: s.last_access,
-          retrievability: r,
-        });
-      }
-    });
-    tx();
-
-    // Build report
-    const decaying = updated.filter(s => s.retrievability < 0.5);
-    const critical = updated.filter(s => s.retrievability < 0.3);
-    const avgR = updated.length > 0
-      ? updated.reduce((sum, s) => sum + s.retrievability, 0) / updated.length
-      : 1.0;
-
-    // Top decaying (sorted by R ascending)
-    const topDecaying = [...decaying]
-      .sort((a, b) => a.retrievability - b.retrievability)
-      .slice(0, 20)
-      .map(s => ({
-        ...s,
-        title: titleMap.get(s.documentId) ?? s.documentId,
-        daysSinceAccess: Math.round(elapsedDays(s.lastAccess, now)),
-      }));
-
-    // Cluster health
-    const clusterData = this.db.prepare(`
-      SELECT ds.document_id, ds.retrievability
-      FROM decay_state ds
-      JOIN documents d ON d.id = ds.document_id
-    `).all() as any[];
-
-    // Get cluster info from graph data cache (simplified: group by first folder)
-    const clusterHealth = this.computeClusterHealth(clusterData);
-
-    return {
-      totalDocuments: updated.length,
-      decayingCount: decaying.length,
-      criticalCount: critical.length,
-      averageR: Math.round(avgR * 100) / 100,
-      topDecaying,
-      clusterHealth,
-    };
-  }
-
-  private computeClusterHealth(data: any[]): DecayReport['clusterHealth'] {
-    // Group by document's top-level folder as proxy for cluster
-    const groups = new Map<string, number[]>();
-    for (const row of data) {
-      const doc = this.db.prepare('SELECT file_path FROM documents WHERE id = ?').get(row.document_id) as any;
-      const folder = doc?.file_path?.split('/')[0] ?? 'unknown';
-      if (!groups.has(folder)) groups.set(folder, []);
-      groups.get(folder)!.push(row.retrievability);
-    }
-
-    return [...groups.entries()]
-      .map(([label, rs]) => ({
-        label,
-        avgR: Math.round((rs.reduce((a, b) => a + b, 0) / rs.length) * 100) / 100,
-        count: rs.length,
-      }))
-      .sort((a, b) => a.avgR - b.avgR);
-  }
-
-  /**
-   * Get documents below decay threshold.
-   */
-  async getDecaying(threshold = 0.5, limit = 20): Promise<Array<DecayState & { title: string }>> {
-    await this.computeAll(); // refresh R values
-
-    const rows = this.db.prepare(`
-      SELECT ds.*, d.title FROM decay_state ds
-      JOIN documents d ON d.id = ds.document_id
-      WHERE ds.retrievability < ?
-      ORDER BY ds.retrievability ASC
-      LIMIT ?
-    `).all(threshold, limit) as any[];
-
-    return rows.map(r => ({
-      documentId: r.document_id,
-      stability: r.stability,
-      difficulty: r.difficulty,
-      lastAccess: r.last_access,
-      retrievability: r.retrievability,
-      title: r.title,
-    }));
-  }
-
-  /**
-   * Initialize decay state for documents that don't have one yet.
-   */
-  async initializeNewDocuments(): Promise<number> {
-    const missing = this.db.prepare(`
-      SELECT d.id, d.content, d.last_modified
-      FROM documents d
-      LEFT JOIN decay_state ds ON d.id = ds.document_id
-      WHERE ds.document_id IS NULL
-    `).all() as any[];
-
-    if (missing.length === 0) return 0;
-
-    const insert = this.db.prepare(`
-      INSERT OR IGNORE INTO decay_state (document_id, stability, difficulty, last_access, retrievability, updated_at)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `);
-
-    const tx = this.db.transaction(() => {
-      for (const doc of missing) {
-        const contentLen = doc.content?.length ?? 500;
-        const initS = estimateInitialStability(contentLen, 1);
-        const lastAccess = doc.last_modified || new Date().toISOString();
-        const elapsed = elapsedDays(lastAccess);
-        const r = computeRetrievability(initS, elapsed);
-        insert.run(doc.id, initS, FSRS_PARAMS.difficulty, lastAccess, r, new Date().toISOString());
-      }
-    });
-    tx();
-
-    return missing.length;
-  }
-}

package/packages/core/src/intelligence/duplicate-detector.ts

@@ -1,71 +0,0 @@
-// Design Ref: 중복/유사 노트 탐지
-// 기존 벡터 임베딩의 cosine similarity 활용
-
-import type { VectorStore } from '../store/types.js';
-
-export interface DuplicatePair {
-  docA: { id: string; title: string; filePath: string };
-  docB: { id: string; title: string; filePath: string };
-  similarity: number;
-}
-
-/**
- * 벡터 유사도 기반 중복 노트 탐지.
- * 문서별 평균 임베딩을 비교하여 threshold 이상인 쌍을 반환.
- */
-export async function detectDuplicates(
-  store: VectorStore,
-  threshold = 0.88,
-  limit = 20,
-): Promise<DuplicatePair[]> {
-  const docs = await store.getAllDocuments();
-  const embeddings = await store.getDocumentEmbeddings();
-
-  if (docs.length < 2) return [];
-
-  // 문서별 평균 임베딩 계산
-  const docVecs = new Map<string, { vec: number[]; title: string; filePath: string }>();
-  for (const doc of docs) {
-    const vec = embeddings.get(doc.id);
-    if (!vec || vec.length === 0) continue;
-    docVecs.set(doc.id, { vec: Array.from(vec), title: doc.title, filePath: doc.filePath });
-  }
-
-  const ids = [...docVecs.keys()];
-  const pairs: DuplicatePair[] = [];
-
-  // O(n²) — 1,200 문서면 ~720K 비교, 수 초 이내
-  for (let i = 0; i < ids.length; i++) {
-    for (let j = i + 1; j < ids.length; j++) {
-      const a = docVecs.get(ids[i])!;
-      const b = docVecs.get(ids[j])!;
-      const sim = cosineSimilarity(a.vec, b.vec);
-
-      if (sim >= threshold) {
-        pairs.push({
-          docA: { id: ids[i], title: a.title, filePath: a.filePath },
-          docB: { id: ids[j], title: b.title, filePath: b.filePath },
-          similarity: Math.round(sim * 1000) / 1000,
-        });
-      }
-    }
-
-    if (pairs.length >= limit * 2) break; // 충분히 찾으면 중단
-  }
-
-  return pairs
-    .sort((a, b) => b.similarity - a.similarity)
-    .slice(0, limit);
-}
-
-function cosineSimilarity(a: number[], b: number[]): number {
-  if (a.length !== b.length) return 0;
-  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];
-  }
-  const denom = Math.sqrt(normA) * Math.sqrt(normB);
-  return denom === 0 ? 0 : dot / denom;
-}