@goshenkata/dryscan-core 1.2.8 → 1.2.10

package/src/services/DuplicationCache.ts

@@ -1,210 +0,0 @@
-import debug from "debug";
-import { DuplicateGroup, IndexUnit } from "../types";
-import { parallelCosineSimilarity } from "./ParallelSimilarity";
-
-const log = debug("DryScan:DuplicationCache");
-
-/**
- * In-memory cache for duplicate comparison scores.
- * Stores a global map of comparison keys and a per-file index for fast invalidation.
- */
-export class DuplicationCache {
-  private static instance: DuplicationCache | null = null;
-
-  private readonly comparisons = new Map<string, number>();
-  private readonly fileIndex = new Map<string, Set<string>>();
-  private initialized = false;
-
-  /** Per-run similarity matrix from a single batched library call (reset each run). */
-  private embSimMatrix: number[][] = [];
-  /** Maps unit ID to its row/column index in embSimMatrix. */
-  private embSimIndex = new Map<string, number>();
-  /** Per-run memoization of parent unit similarity scores (reset each run). */
-  private parentSimCache = new Map<string, number>();
-
-  static getInstance(): DuplicationCache {
-    if (!DuplicationCache.instance) {
-      DuplicationCache.instance = new DuplicationCache();
-    }
-    return DuplicationCache.instance;
-  }
-
-  /**
-   * Updates the cache with fresh duplicate groups. Not awaited by callers to avoid blocking.
-   */
-  async update(groups: DuplicateGroup[]): Promise<void> {
-    if (!groups) return;
-
-    for (const group of groups) {
-      const key = this.makeKey(group.left.id, group.right.id);
-      this.comparisons.set(key, group.similarity);
-      this.addKeyForFile(group.left.filePath, key);
-      this.addKeyForFile(group.right.filePath, key);
-    }
-
-    this.initialized = this.initialized || groups.length > 0;
-  }
-
-  /**
-   * Retrieves a cached similarity if present and valid for both file paths.
-   * Returns null when the cache has not been initialized or when the pair is missing.
-   */
-  get(leftId: string, rightId: string, leftFilePath: string, rightFilePath: string): number | null {
-    if (!this.initialized) return null;
-
-    const key = this.makeKey(leftId, rightId);
-    if (!this.fileHasKey(leftFilePath, key) || !this.fileHasKey(rightFilePath, key)) {
-      return null;
-    }
-
-    const value = this.comparisons.get(key);
-    return typeof value === "number" ? value : null;
-  }
-
-  /**
-   * Invalidates all cached comparisons involving the provided file paths.
-   */
-  async invalidate(paths: string[]): Promise<void> {
-    if (!this.initialized || !paths || paths.length === 0) return;
-
-    const unique = new Set(paths);
-    for (const filePath of unique) {
-      const keys = this.fileIndex.get(filePath);
-      if (!keys) continue;
-
-      for (const key of keys) {
-        this.comparisons.delete(key);
-        for (const [otherPath, otherKeys] of this.fileIndex.entries()) {
-          if (otherKeys.delete(key) && otherKeys.size === 0) {
-            this.fileIndex.delete(otherPath);
-          }
-        }
-      }
-
-      this.fileIndex.delete(filePath);
-    }
-
-    if (this.comparisons.size === 0) {
-      this.initialized = false;
-    }
-  }
-
-  /**
-   * Clears all cached data. Intended for test setup.
-   */
-  clear(): void {
-    this.comparisons.clear();
-    this.fileIndex.clear();
-    this.initialized = false;
-    this.embSimMatrix = [];
-    this.embSimIndex.clear();
-    this.clearRunCaches();
-  }
-
-  /**
-   * Resets per-run memoization (parent similarities).
-   * The embedding matrix is intentionally preserved so incremental runs can
-   * reuse clean×clean values across calls.
-   */
-  clearRunCaches(): void {
-    this.parentSimCache.clear();
-  }
-
-  /**
-   * Builds or incrementally updates the embedding similarity matrix.
-   *
-   * Full rebuild (default): replaces the entire matrix — O(n²).
-   * Incremental (dirtyPaths provided + prior matrix exists): copies clean×clean
-   * cells from the old matrix and recomputes only dirty rows via one batched
-   * cosineSimilarity call — O(d·n) where d = number of dirty units.
-   */
-  async buildEmbSimCache(units: IndexUnit[], dirtyPaths?: string[]): Promise<void> {
-    const embedded = units.filter(u => Array.isArray(u.embedding) && u.embedding.length > 0);
-    if (embedded.length < 2) {
-      this.embSimMatrix = [];
-      this.embSimIndex.clear();
-      return;
-    }
-
-    const embeddings = embedded.map(u => u.embedding as number[]);
-    const newIndex = new Map(embedded.map((u, i) => [u.id, i] as [string, number]));
-    const dirtySet = dirtyPaths ? new Set(dirtyPaths) : null;
-    const hasPriorMatrix = this.embSimMatrix.length > 0;
-
-    if (!dirtySet || !hasPriorMatrix) {
-      // Full rebuild
-      this.embSimIndex = newIndex;
-      this.embSimMatrix = await parallelCosineSimilarity(embeddings, embeddings);
-      log("Built full embedding similarity matrix: %d units", embedded.length);
-      return;
-    }
-
-    // Incremental: identify dirty unit IDs
-    const dirtyIds = new Set(embedded.filter(u => dirtySet.has(u.filePath)).map(u => u.id));
-
-    if (dirtyIds.size === 0) {
-      log("Matrix reused: no dirty units detected");
-      return;
-    }
-
-    const n = embedded.length;
-
-    // Start with zeroes; copy clean×clean values from prior matrix
-    const newMatrix: number[][] = Array.from({ length: n }, () => new Array(n).fill(0));
-    for (let i = 0; i < n; i++) {
-      for (let j = 0; j < n; j++) {
-        if (dirtyIds.has(embedded[i].id) || dirtyIds.has(embedded[j].id)) continue;
-        const oi = this.embSimIndex.get(embedded[i].id);
-        const oj = this.embSimIndex.get(embedded[j].id);
-        if (oi !== undefined && oj !== undefined) newMatrix[i][j] = this.embSimMatrix[oi][oj];
-      }
-    }
-
-    // Recompute dirty rows in one batched call
-    const dirtyIndices = embedded.reduce<number[]>((acc, u, i) => (dirtyIds.has(u.id) ? [...acc, i] : acc), []);
-    const dirtyRows = await parallelCosineSimilarity(dirtyIndices.map(i => embeddings[i]), embeddings);
-    dirtyIndices.forEach((rowIdx, di) => {
-      for (let j = 0; j < n; j++) {
-        newMatrix[rowIdx][j] = dirtyRows[di][j];
-        newMatrix[j][rowIdx] = dirtyRows[di][j];
-      }
-    });
-
-    this.embSimIndex = newIndex;
-    this.embSimMatrix = newMatrix;
-    log("Incremental matrix update: %d dirty unit(s) out of %d total", dirtyIds.size, n);
-  }
-
-  /** Returns the pre-computed cosine similarity for a pair of unit IDs, if available. */
-  getEmbSim(id1: string, id2: string): number | undefined {
-    const i = this.embSimIndex.get(id1);
-    const j = this.embSimIndex.get(id2);
-    if (i === undefined || j === undefined) return undefined;
-    return this.embSimMatrix[i][j];
-  }
-
-  /** Returns the memoized parent similarity for the given stable key, if available. */
-  getParentSim(key: string): number | undefined {
-    return this.parentSimCache.get(key);
-  }
-
-  /** Stores a memoized parent similarity for the given stable key. */
-  setParentSim(key: string, sim: number): void {
-    this.parentSimCache.set(key, sim);
-  }
-
-  private addKeyForFile(filePath: string, key: string): void {
-    const current = this.fileIndex.get(filePath) ?? new Set<string>();
-    current.add(key);
-    this.fileIndex.set(filePath, current);
-  }
-
-  private fileHasKey(filePath: string, key: string): boolean {
-    const keys = this.fileIndex.get(filePath);
-    return keys ? keys.has(key) : false;
-  }
-
-  private makeKey(leftId: string, rightId: string): string {
-    return [leftId, rightId].sort().join("::");
-  }
-}

package/src/services/EmbeddingService.ts

@@ -1,81 +0,0 @@
-import debug from "debug";
-import { OllamaEmbeddings } from "@langchain/ollama";
-import { HuggingFaceInferenceEmbeddings } from "@langchain/community/embeddings/hf";
-import { IndexUnit } from "../types";
-import { configStore } from "../config/configStore";
-
-const log = debug("DryScan:EmbeddingService");
-
-// Model names for each provider
-const OLLAMA_MODEL = "qwen3-embedding:0.6b";
-const HUGGINGFACE_MODEL = "Qwen/Qwen3-Embedding-0.6B";
-
-export class EmbeddingService {
-    constructor(private readonly repoPath: string) { }
-
-    /**
-     * Generates an embedding for the given index unit using the configured provider.
-     * Skips embedding if code exceeds the configured context length.
-     */
-    async addEmbedding(fn: IndexUnit): Promise<IndexUnit> {
-        const config = await configStore.get(this.repoPath);
-        const maxContext = config?.contextLength ?? 2048;
-        if (fn.code.length > maxContext) {
-            log(
-                "Skipping embedding for %s (code length %d exceeds context %d)",
-                fn.id,
-                fn.code.length,
-                maxContext
-            );
-            return { ...fn, embedding: null };
-        }
-
-        const source = config.embeddingSource;
-        if (!source) {
-            const message = `Embedding source is not configured for repository at ${this.repoPath}`;
-            log(message);
-            throw new Error(message);
-        }
-
-        const embeddings = this.buildProvider(source);
-        const embedding = await embeddings.embedQuery(fn.code);
-        return { ...fn, embedding };
-    }
-
-    /**
-     * Builds the embedding provider based on the source configuration.
-     * - URL (http/https): Uses Ollama with "embeddinggemma" model
-     * - "huggingface": Uses HuggingFace Inference API with "embeddinggemma-300m" model
-     */
-    private buildProvider(source: string) {
-        // HuggingFace Inference API
-        if (source.toLowerCase() === "huggingface") {
-            log("Using HuggingFace Inference with model: %s", HUGGINGFACE_MODEL);
-            return new HuggingFaceInferenceEmbeddings({
-                model: HUGGINGFACE_MODEL,
-                provider: "hf-inference",
-            });
-        }
-
-        // Ollama keyword or direct URL
-        const ollamaBaseUrl = this.resolveOllamaBaseUrl(source);
-        if (ollamaBaseUrl !== null) {
-            log("Using Ollama%s with model: %s", ollamaBaseUrl ? ` at ${ollamaBaseUrl}` : "", OLLAMA_MODEL);
-            return new OllamaEmbeddings({ model: OLLAMA_MODEL, ...(ollamaBaseUrl && { baseUrl: ollamaBaseUrl }) });
-        }
-
-        const message = `Unsupported embedding source: ${source || "(empty)"}. Use "huggingface" or an Ollama URL.`;
-        log(message);
-        throw new Error(message);
-    }
-
-    /**
-     * Returns the Ollama base URL if source is an HTTP URL, undefined if source is "ollama" (use default),
-     * or null if source is not an Ollama provider at all.
-     */
-    private resolveOllamaBaseUrl(source: string): string | undefined | null {
-        if (/^https?:\/\//i.test(source)) return source;
-        if (source.toLowerCase() === "ollama") return undefined;
-        return null;
-    }
-}

package/src/services/ExclusionService.ts

@@ -1,102 +0,0 @@
-import { DryConfig } from "../types";
-import { configStore } from "../config/configStore";
-import { DryScanServiceDeps } from "./types";
-import { IndexUnitType } from "../types";
-import { minimatch } from "minimatch";
-import { ParsedPairKey } from "./PairingService";
-
-export class ExclusionService {
-  private config?: DryConfig;
-
-  constructor(private readonly deps: DryScanServiceDeps) {}
-
-  async cleanupExcludedFiles(): Promise<void> {
-    const config = await this.loadConfig();
-    if (!config.excludedPaths || config.excludedPaths.length === 0) return;
-
-    const units = await this.deps.db.getAllUnits();
-    const files = await this.deps.db.getAllFiles();
-
-    const unitPathsToRemove = new Set<string>();
-    for (const unit of units) {
-      if (this.pathExcluded(unit.filePath)) {
-        unitPathsToRemove.add(unit.filePath);
-      }
-    }
-
-    const filePathsToRemove = new Set<string>();
-    for (const file of files) {
-      if (this.pathExcluded(file.filePath)) {
-        filePathsToRemove.add(file.filePath);
-      }
-    }
-
-    const paths = [...new Set([...unitPathsToRemove, ...filePathsToRemove])];
-    if (paths.length > 0) {
-      await this.deps.db.removeUnitsByFilePaths(paths);
-      await this.deps.db.removeFilesByFilePaths(paths);
-    }
-  }
-
-  async cleanExclusions(): Promise<{ removed: number; kept: number }> {
-    const config = await this.loadConfig();
-    const units = await this.deps.db.getAllUnits();
-
-    const actualPairsByType = {
-      [IndexUnitType.CLASS]: this.buildPairKeys(units, IndexUnitType.CLASS),
-      [IndexUnitType.FUNCTION]: this.buildPairKeys(units, IndexUnitType.FUNCTION),
-      [IndexUnitType.BLOCK]: this.buildPairKeys(units, IndexUnitType.BLOCK),
-    };
-
-    const kept: string[] = [];
-    const removed: string[] = [];
-
-    for (const entry of config.excludedPairs || []) {
-      const parsed = this.deps.pairing.parsePairKey(entry);
-      if (!parsed) {
-        removed.push(entry);
-        continue;
-      }
-
-      const candidates = actualPairsByType[parsed.type];
-      const matched = candidates.some((actual) => this.deps.pairing.pairKeyMatches(actual, parsed));
-      if (matched) {
-        kept.push(entry);
-      } else {
-        removed.push(entry);
-      }
-    }
-
-    const nextConfig: DryConfig = { ...config, excludedPairs: kept };
-    await configStore.save(this.deps.repoPath, nextConfig);
-    this.config = nextConfig;
-
-    return { removed: removed.length, kept: kept.length };
-  }
-
-  private pathExcluded(filePath: string): boolean {
-    const config = this.config;
-    if (!config || !config.excludedPaths || config.excludedPaths.length === 0) return false;
-    return config.excludedPaths.some((pattern) => minimatch(filePath, pattern, { dot: true }));
-  }
-
-  private buildPairKeys(units: any[], type: IndexUnitType): ParsedPairKey[] {
-    const typed = units.filter((u) => u.unitType === type);
-    const pairs: ParsedPairKey[] = [];
-    for (let i = 0; i < typed.length; i++) {
-      for (let j = i + 1; j < typed.length; j++) {
-        const key = this.deps.pairing.pairKeyForUnits(typed[i], typed[j]);
-        const parsed = key ? this.deps.pairing.parsePairKey(key) : null;
-        if (parsed) {
-          pairs.push(parsed);
-        }
-      }
-    }
-    return pairs;
-  }
-
-  private async loadConfig(): Promise<DryConfig> {
-    this.config = await configStore.get(this.deps.repoPath);
-    return this.config;
-  }
-}

package/src/services/PairingService.ts

@@ -1,145 +0,0 @@
-import crypto from "node:crypto";
-import debug from "debug";
-import { minimatch } from "minimatch";
-import { LanguageExtractor } from "../extractors/LanguageExtractor";
-import { IndexUnitExtractor } from "../IndexUnitExtractor";
-import { IndexUnit, IndexUnitType } from "../types";
-import { BLOCK_HASH_ALGO } from "../const";
-
-const log = debug("DryScan:pairs");
-
-type UnitLike = Pick<IndexUnit, "unitType" | "filePath" | "name" | "code">;
-
-export interface ParsedPairKey {
-  type: IndexUnitType;
-  left: string;
-  right: string;
-  key: string;
-}
-
-/**
- * Service for building and parsing pair keys with extractor-aware labeling.
- */
-export class PairingService {
-  constructor(private readonly indexUnitExtractor: IndexUnitExtractor) {}
-
-  /**
-   * Creates a stable, order-independent key for two units of the same type.
-   * Returns null when units differ in type so callers can skip invalid pairs.
-   */
-  pairKeyForUnits(left: UnitLike, right: UnitLike): string | null {
-    if (left.unitType !== right.unitType) {
-      log("Skipping pair with mismatched types: %s vs %s", left.unitType, right.unitType);
-      return null;
-    }
-    const type = left.unitType;
-    const leftLabel = this.unitLabel(left);
-    const rightLabel = this.unitLabel(right);
-    const [a, b] = [leftLabel, rightLabel].sort();
-    return `${type}|${a}|${b}`;
-  }
-
-  /**
-   * Parses a raw pair key into its components, returning null for malformed values.
-   * Sorting is applied so callers can compare pairs without worrying about order.
-   */
-  parsePairKey(value: string): ParsedPairKey | null {
-    const parts = value.split("|");
-    if (parts.length !== 3) {
-      log("Invalid pair key format: %s", value);
-      return null;
-    }
-    const [typeRaw, leftRaw, rightRaw] = parts;
-    const type = this.stringToUnitType(typeRaw);
-    if (!type) {
-      log("Unknown unit type in pair key: %s", typeRaw);
-      return null;
-    }
-    const [left, right] = [leftRaw, rightRaw].sort();
-    return { type, left, right, key: `${type}|${left}|${right}` };
-  }
-
-  /**
-   * Checks whether an actual pair key satisfies a pattern, with glob matching for class paths.
-   */
-  pairKeyMatches(actual: ParsedPairKey, pattern: ParsedPairKey): boolean {
-    if (actual.type !== pattern.type) return false;
-    if (actual.type === IndexUnitType.CLASS) {
-      // Allow glob matching for class file paths.
-      const forward =
-        minimatch(actual.left, pattern.left, { dot: true }) &&
-        minimatch(actual.right, pattern.right, { dot: true });
-      const swapped =
-        minimatch(actual.left, pattern.right, { dot: true }) &&
-        minimatch(actual.right, pattern.left, { dot: true });
-      return forward || swapped;
-    }
-
-    // Functions and blocks use exact matching on canonical strings.
-    return (
-      (actual.left === pattern.left && actual.right === pattern.right) ||
-      (actual.left === pattern.right && actual.right === pattern.left)
-    );
-  }
-
-  /**
-   * Derives a reversible, extractor-aware label for a unit.
-   * Extractors may override; fallback uses a fixed format per unit type.
-   */
-  unitLabel(unit: UnitLike): string {
-    const extractor = this.findExtractor(unit.filePath);
-    const customLabel = extractor?.unitLabel?.(unit as IndexUnit);
-    if (customLabel) return customLabel;
-
-    switch (unit.unitType) {
-      case IndexUnitType.CLASS:
-        return unit.filePath;
-      case IndexUnitType.FUNCTION:
-        return this.canonicalFunctionSignature(unit);
-      case IndexUnitType.BLOCK:
-        return this.normalizedBlockHash(unit);
-      default:
-        return unit.name;
-    }
-  }
-
-  private findExtractor(filePath: string): LanguageExtractor | undefined {
-    return this.indexUnitExtractor.extractors.find((ex) => ex.supports(filePath));
-  }
-
-  private canonicalFunctionSignature(unit: UnitLike): string {
-    const arity = this.extractArity(unit.code);
-    return `${unit.name}(arity:${arity})`;
-  }
-
-  /**
-   * Normalizes block code (strips comments/whitespace) and hashes it for pair matching.
-   */
-  private normalizedBlockHash(unit: UnitLike): string {
-    const normalized = this.normalizeCode(unit.code);
-    return crypto.createHash(BLOCK_HASH_ALGO).update(normalized).digest("hex");
-  }
-
-  private stringToUnitType(value: string): IndexUnitType | null {
-    if (value === IndexUnitType.CLASS) return IndexUnitType.CLASS;
-    if (value === IndexUnitType.FUNCTION) return IndexUnitType.FUNCTION;
-    if (value === IndexUnitType.BLOCK) return IndexUnitType.BLOCK;
-    return null;
-  }
-
-  private extractArity(code: string): number {
-    const match = code.match(/^[^{]*?\(([^)]*)\)/s);
-    if (!match) return 0;
-    const params = match[1]
-      .split(",")
-      .map((p) => p.trim())
-      .filter(Boolean);
-    return params.length;
-  }
-
-  private normalizeCode(code: string): string {
-    const withoutBlockComments = code.replace(/\/\*[\s\S]*?\*\//g, "");
-    const withoutLineComments = withoutBlockComments.replace(/\/\/[^\n\r]*/g, "");
-    return withoutLineComments.replace(/\s+/g, "");
-  }
-}

package/src/services/ParallelSimilarity.ts

@@ -1,59 +0,0 @@
-import os from "node:os";
-import { Worker } from "node:worker_threads";
-import { cosineSimilarity } from "@langchain/core/utils/math";
-
-/** Minimum row count below which synchronous is faster than worker overhead. */
-const MIN_PARALLEL_ROWS = 50;
-
-/**
- * Computes cosineSimilarity(A, B) using worker threads for large inputs,
- * falling back to the synchronous library call for small ones.
- * B is packed into a SharedArrayBuffer shared across all workers — no copies.
- */
-export async function parallelCosineSimilarity(A: number[][], B: number[][]): Promise<number[][]> {
-  if (A.length === 0 || B.length === 0) return [];
-  if (A.length < MIN_PARALLEL_ROWS) return cosineSimilarity(A, B);
-
-  const dims = A[0].length;
-  const chunkSize = Math.ceil(A.length / os.cpus().length);
-
-  const sharedB = new SharedArrayBuffer(B.length * dims * 8);
-  const bView = new Float64Array(sharedB);
-  B.forEach((row, i) => bView.set(row, i * dims));
-
-  // import.meta.resolve respects the active module loader:
-  // under tsx it remaps .js → .ts; in compiled output it stays .js.
-  const workerUrl = new URL("./services/cosineSimilarityWorker.js", import.meta.url);
-  const execArgv = workerUrl.pathname.endsWith(".ts") ? ["--import", "tsx/esm"] : [];
-
-  const chunks = Array.from(
-    { length: Math.ceil(A.length / chunkSize) },
-    (_, i) => A.slice(i * chunkSize, (i + 1) * chunkSize),
-  );
-
-  const results = await Promise.all(chunks.map(chunk => runWorker(chunk, sharedB, B.length, dims, workerUrl, execArgv)));
-  return results.flat();
-}
-
-function runWorker(
-  chunk: number[][],
-  sharedB: SharedArrayBuffer,
-  bCount: number,
-  dims: number,
-  workerUrl: URL,
-  execArgv: string[],
-): Promise<number[][]> {
-  return new Promise((resolve, reject) => {
-    const rowsFlat = new Float64Array(chunk.length * dims);
-    chunk.forEach((row, i) => rowsFlat.set(row, i * dims));
-
-    const worker = new Worker(workerUrl, {
-      workerData: { rowsBuffer: rowsFlat.buffer, rowCount: chunk.length, allBuffer: sharedB, allCount: bCount, dims },
-      transferList: [rowsFlat.buffer],
-      execArgv,
-    });
-
-    worker.once("message", ({ result }) => resolve(result));
-    worker.once("error", reject);
-  });
-}

package/src/services/RepositoryInitializer.ts

@@ -1,93 +0,0 @@
-import path from "path";
-import fs from "fs/promises";
-import { DryScanServiceDeps } from "./types";
-import { ExclusionService } from "./ExclusionService";
-import { IndexUnit } from "../types";
-import { EmbeddingService } from "./EmbeddingService";
-import { FileEntity } from "../db/entities/FileEntity";
-import { IndexUnitExtractor } from "../IndexUnitExtractor";
-
-export interface InitOptions {
-  skipEmbeddings?: boolean;
-}
-
-export class RepositoryInitializer {
-  constructor(
-    private readonly deps: DryScanServiceDeps,
-    private readonly exclusionService: ExclusionService
-  ) {}
-
-  async init(options?: InitOptions): Promise<void> {
-    const extractor = this.deps.extractor;
-
-    console.log("[DryScan] Phase 1/3: Extracting code units...");
-    await this.initUnits(extractor);
-    console.log("[DryScan] Phase 2/3: Computing embeddings (may be slow)...");
-    await this.computeEmbeddings(options?.skipEmbeddings === true);
-    console.log("[DryScan] Phase 3/3: Tracking files...");
-    await this.trackFiles(extractor);
-    await this.exclusionService.cleanupExcludedFiles();
-    console.log("[DryScan] Initialization phases complete.");
-  }
-
-  private async initUnits(extractor: IndexUnitExtractor): Promise<void> {
-    const units = await extractor.scan(this.deps.repoPath);
-    console.log(`[DryScan] Extracted ${units.length} index units.`);
-    await this.deps.db.saveUnits(units);
-  }
-
-  private async computeEmbeddings(skipEmbeddings: boolean): Promise<void> {
-    if (skipEmbeddings) {
-      console.log("[DryScan] Skipping embedding computation by request.");
-      return;
-    }
-    const allUnits: IndexUnit[] = await this.deps.db.getAllUnits();
-    const total = allUnits.length;
-    console.log(`[DryScan] Computing embeddings for ${total} units...`);
-
-    const updated: IndexUnit[] = [];
-    const progressInterval = Math.max(1, Math.ceil(total / 10));
-    const embeddingService = new EmbeddingService(this.deps.repoPath);
-
-    for (let i = 0; i < total; i++) {
-      const unit = allUnits[i];
-      try {
-        const enriched = await embeddingService.addEmbedding(unit);
-        updated.push(enriched);
-      } catch (err: any) {
-        console.error(
-          `[DryScan] Embedding failed for ${unit.filePath} (${unit.name}): ${err?.message || err}`
-        );
-        throw err;
-      }
-
-      const completed = i + 1;
-      if (completed === total || completed % progressInterval === 0) {
-        const pct = Math.floor((completed / total) * 100);
-        console.log(`[DryScan] Embeddings ${completed}/${total} (${pct}%)`);
-      }
-    }
-
-    await this.deps.db.updateUnits(updated);
-  }
-
-  private async trackFiles(extractor: IndexUnitExtractor): Promise<void> {
-    const allFunctions = await extractor.listSourceFiles(this.deps.repoPath);
-    const fileEntities: FileEntity[] = [];
-
-    for (const relPath of allFunctions) {
-      const fullPath = path.join(this.deps.repoPath, relPath);
-      const stat = await fs.stat(fullPath);
-      const checksum = await extractor.computeChecksum(fullPath);
-
-      const fileEntity = new FileEntity();
-      fileEntity.filePath = relPath;
-      fileEntity.checksum = checksum;
-      fileEntity.mtime = stat.mtimeMs;
-      fileEntities.push(fileEntity);
-    }
-
-    await this.deps.db.saveFiles(fileEntities);
-    console.log(`[DryScan] Tracked ${fileEntities.length} files.`);
-  }
-}