@monoes/monograph 1.5.3 → 1.5.4

package/src/analysis/trace.ts

@@ -1,300 +0,0 @@
-export type TraceReason = 'no_references' | 'only_re_exported' | 'self_import' | 'has_references';
-
-export interface ReferenceLocation {
-  filePath: string;
-  line: number;
-  col: number;
-}
-
-export interface ReExportChain {
-  path: string;
-  exportName: string;
-}
-
-export interface ExportTrace {
-  file: string;
-  exportName: string;
-  isUsed: boolean;
-  directReferences: ReferenceLocation[];
-  reExportChains: ReExportChain[];
-  reason: TraceReason;
-}
-
-export interface FileTrace {
-  file: string;
-  exports: Array<{ name: string; isUsed: boolean; line: number }>;
-  importsFrom: string[];
-  importedBy: string[];
-  reExports: Array<{ name: string; fromFile: string }>;
-}
-
-export interface DependencyTrace {
-  packageName: string;
-  directImporters: string[];
-  transitiveImporters: string[];
-  isUsed: boolean;
-}
-
-export interface CloneInstance {
-  filePath: string;
-  startLine: number;
-  endLine: number;
-  similarity: number;
-}
-
-export interface CloneTrace {
-  sourceFile: string;
-  sourceLine: number;
-  matchingInstances: CloneInstance[];
-  groupId?: number;
-}
-
-export interface GraphNode {
-  id: string;
-  filePath?: string;
-  name: string;
-  isExported: boolean;
-  startLine?: number;
-}
-
-interface GraphEdge {
-  sourceId: string;
-  targetId: string;
-  relation: string;
-}
-
-interface Graph {
-  nodes: GraphNode[];
-  edges: GraphEdge[];
-}
-
-/** Build an O(1) id→node index. Pass to the trace functions when calling multiple times on the same graph. */
-export function buildNodeIndex(graph: Graph): Map<string, GraphNode> {
-  const index = new Map<string, GraphNode>();
-  for (const n of graph.nodes) index.set(n.id, n);
-  return index;
-}
-
-export function traceExport(
-  graph: Graph,
-  file: string,
-  exportName: string,
-  nodeIndex?: Map<string, GraphNode>,
-): ExportTrace {
-  // Build index once if not supplied — O(N) amortised when caller reuses it
-  const idx = nodeIndex ?? buildNodeIndex(graph);
-
-  // Find nodes in the target file matching exportName
-  const targetIds = new Set<string>();
-  for (const n of graph.nodes) {
-    if (n.filePath === file && n.name === exportName) targetIds.add(n.id);
-  }
-
-  // Find CALLS or IMPORTS edges pointing to these nodes from other files
-  const directReferences: ReferenceLocation[] = [];
-  const reExportChains: ReExportChain[] = [];
-
-  for (const edge of graph.edges) {
-    if (!targetIds.has(edge.targetId)) continue;
-
-    const sourceNode = idx.get(edge.sourceId);
-    if (!sourceNode) continue;
-
-    // Skip self-references (same file)
-    if (sourceNode.filePath === file) continue;
-
-    if (edge.relation === 'CALLS' || edge.relation === 'IMPORTS') {
-      directReferences.push({
-        filePath: sourceNode.filePath ?? sourceNode.id,
-        line: sourceNode.startLine ?? 0,
-        col: 0,
-      });
-    } else if (edge.relation === 'RE_EXPORTS') {
-      reExportChains.push({
-        path: sourceNode.filePath ?? sourceNode.id,
-        exportName: sourceNode.name,
-      });
-    }
-  }
-
-  // Determine reason
-  let reason: TraceReason;
-  let isUsed: boolean;
-
-  if (directReferences.length > 0) {
-    reason = 'has_references';
-    isUsed = true;
-  } else if (reExportChains.length > 0) {
-    reason = 'only_re_exported';
-    isUsed = false;
-  } else {
-    reason = 'no_references';
-    isUsed = false;
-  }
-
-  return {
-    file,
-    exportName,
-    isUsed,
-    directReferences,
-    reExportChains,
-    reason,
-  };
-}
-
-export function traceFile(
-  graph: Graph,
-  file: string,
-  nodeIndex?: Map<string, GraphNode>,
-): FileTrace {
-  // Build index once if not supplied
-  const idx = nodeIndex ?? buildNodeIndex(graph);
-
-  // Find all nodes in this file
-  const fileNodes = graph.nodes.filter((n) => n.filePath === file);
-  const fileNodeIds = new Set(fileNodes.map((n) => n.id));
-
-  // Pre-compute which target node ids have external references in one edge pass
-  // to avoid O(exported_nodes * edges) in the map below.
-  const externallyReferenced = new Set<string>();
-  const importsFromSet = new Set<string>();
-  const importedBySet = new Set<string>();
-  const reExports: Array<{ name: string; fromFile: string }> = [];
-
-  for (const edge of graph.edges) {
-    const srcInFile = fileNodeIds.has(edge.sourceId);
-    const tgtInFile = fileNodeIds.has(edge.targetId);
-
-    if (edge.relation === 'IMPORTS') {
-      if (srcInFile) {
-        const targetNode = idx.get(edge.targetId);
-        if (targetNode?.filePath && targetNode.filePath !== file) {
-          importsFromSet.add(targetNode.filePath);
-        }
-      }
-      if (tgtInFile) {
-        const sourceNode = idx.get(edge.sourceId);
-        if (sourceNode?.filePath && sourceNode.filePath !== file) {
-          importedBySet.add(sourceNode.filePath);
-        }
-      }
-      // External IMPORTS into a file node → that node is externally referenced
-      if (tgtInFile && !srcInFile) {
-        externallyReferenced.add(edge.targetId);
-      }
-    }
-
-    if (edge.relation === 'CALLS' && tgtInFile && !srcInFile) {
-      externallyReferenced.add(edge.targetId);
-    }
-
-    if (edge.relation === 'RE_EXPORTS' && srcInFile) {
-      const sourceNode = idx.get(edge.sourceId);
-      const targetNode = idx.get(edge.targetId);
-      if (sourceNode && targetNode?.filePath) {
-        reExports.push({ name: sourceNode.name, fromFile: targetNode.filePath });
-      }
-    }
-  }
-
-  // Build exports list using pre-computed set — O(exported_nodes) not O(exported_nodes * edges)
-  const exports = fileNodes
-    .filter((n) => n.isExported)
-    .map((n) => ({
-      name: n.name,
-      isUsed: externallyReferenced.has(n.id),
-      line: n.startLine ?? 0,
-    }));
-
-  return {
-    file,
-    exports,
-    importsFrom: Array.from(importsFromSet),
-    importedBy: Array.from(importedBySet),
-    reExports,
-  };
-}
-
-export function traceDependency(
-  importEdges: Array<{ sourceFile: string; targetPackage: string }>,
-  packageName: string,
-): DependencyTrace {
-  // Find direct importers
-  const directImporters = importEdges
-    .filter((e) => e.targetPackage === packageName)
-    .map((e) => e.sourceFile);
-
-  const directSet = new Set(directImporters);
-
-  // BFS to find transitive importers via reverse import graph
-  const reverseImportMap = new Map<string, Set<string>>();
-  for (const edge of importEdges) {
-    if (!reverseImportMap.has(edge.targetPackage)) {
-      reverseImportMap.set(edge.targetPackage, new Set());
-    }
-    reverseImportMap.get(edge.targetPackage)!.add(edge.sourceFile);
-  }
-
-  const transitiveSet = new Set<string>();
-  const queue = [...directImporters];
-  const visited = new Set(directImporters);
-
-  while (queue.length > 0) {
-    const current = queue.shift()!;
-    const upstream = reverseImportMap.get(current);
-    if (upstream) {
-      for (const file of upstream) {
-        if (!visited.has(file) && !directSet.has(file)) {
-          visited.add(file);
-          transitiveSet.add(file);
-          queue.push(file);
-        }
-      }
-    }
-  }
-
-  return {
-    packageName,
-    directImporters,
-    transitiveImporters: Array.from(transitiveSet),
-    isUsed: directImporters.length > 0 || transitiveSet.size > 0,
-  };
-}
-
-export function traceClone(
-  cloneGroups: Array<{ id: number; instances: CloneInstance[] }>,
-  file: string,
-  line: number,
-): CloneTrace {
-  // Find groups containing an instance at (file, line)
-  const matchingGroups = cloneGroups.filter((group) =>
-    group.instances.some(
-      (inst) =>
-        inst.filePath === file && inst.startLine <= line && inst.endLine >= line,
-    ),
-  );
-
-  if (matchingGroups.length === 0) {
-    return {
-      sourceFile: file,
-      sourceLine: line,
-      matchingInstances: [],
-      groupId: undefined,
-    };
-  }
-
-  // Use the first matching group
-  const group = matchingGroups[0];
-
-  // Return all OTHER instances (not the source one)
-  const matchingInstances = group.instances.filter(
-    (inst) => !(inst.filePath === file && inst.startLine <= line && inst.endLine >= line),
-  );
-
-  return {
-    sourceFile: file,
-    sourceLine: line,
-    matchingInstances,
-    groupId: group.id,
-  };
-}

package/src/analysis/worker-pool.ts

@@ -1,81 +0,0 @@
-import { Worker } from 'node:worker_threads';
-import { cpus } from 'node:os';
-
-const DEFAULT_STACK_SIZE_MB = 16;
-
-export interface WorkerPoolOptions {
-  threads?: number;
-  stackSizeMb?: number;
-}
-
-interface QueuedTask {
-  script: string;
-  input: unknown;
-  resolve: (value: unknown) => void;
-  reject: (reason: unknown) => void;
-}
-
-let _globalPool: WorkerPool | null = null;
-
-export class WorkerPool {
-  readonly threads: number;
-  readonly stackSizeMb: number;
-
-  private _active = 0;
-  private readonly _queue: QueuedTask[] = [];
-
-  constructor(opts: WorkerPoolOptions = {}) {
-    this.threads = opts.threads ?? cpus().length;
-    this.stackSizeMb = opts.stackSizeMb ?? DEFAULT_STACK_SIZE_MB;
-  }
-
-  run<T>(workerScript: string, input: unknown): Promise<T> {
-    return new Promise<T>((resolve, reject) => {
-      this._queue.push({ script: workerScript, input, resolve: resolve as (v: unknown) => void, reject });
-      this._drain();
-    });
-  }
-
-  private _drain(): void {
-    while (this._active < this.threads && this._queue.length > 0) {
-      const task = this._queue.shift()!;
-      this._active++;
-      const worker = new Worker(task.script, {
-        workerData: task.input,
-        resourceLimits: { stackSizeMb: this.stackSizeMb },
-      });
-      let settled = false;
-      const settle = (fn: () => void) => {
-        if (settled) return;
-        settled = true;
-        fn();
-        this._active--;
-        this._drain();
-      };
-      worker.on('message', (v: unknown) => {
-        settle(() => task.resolve(v));
-      });
-      worker.on('error', (err: unknown) => {
-        settle(() => task.reject(err));
-      });
-      worker.on('exit', (code: number) => {
-        if (code !== 0) {
-          settle(() => task.reject(new Error(`Worker exited with code ${code}`)));
-        }
-      });
-    }
-  }
-}
-
-export function configureGlobalPool(threads?: number, stackSizeMb?: number): WorkerPool {
-  if (!_globalPool) _globalPool = new WorkerPool({ threads, stackSizeMb });
-  return _globalPool;
-}
-
-export function getGlobalPool(): WorkerPool {
-  return _globalPool ?? configureGlobalPool();
-}
-
-export function resetGlobalPool(): void {
-  _globalPool = null;
-}

package/src/graph/clone-detector.ts

@@ -1,163 +0,0 @@
-import type { MonographDb } from '../storage/db.js';
-import { insertEdge } from '../storage/edge-store.js';
-import { makeId } from '../types.js';
-
-export interface ClonePair {
-  fileA: string;
-  fileB: string;
-  similarity: number;    // 0-1
-  cloneType: 'exact' | 'renamed' | 'structural';
-  tokenCount: number;    // shared token run length
-}
-
-export interface CloneDetectionResult {
-  pairs: ClonePair[];
-  totalFiles: number;
-  cloneRatio: number;    // fraction of files involved in at least one clone pair
-}
-
-/** Tokenize a file path into lowercase alphanumeric tokens. */
-function tokenizePath(filePath: string): string[] {
-  return filePath
-    .toLowerCase()
-    .split(/[^a-z0-9]+/)
-    .filter(t => t.length > 0);
-}
-
-/** Extract the base filename (without directory) from a path. */
-function baseName(filePath: string): string {
-  return filePath.replace(/^.*[\\/]/, '');
-}
-
-/**
- * Compute both Jaccard similarity and shared token count in a single pass.
- * Avoids building the countA Map twice (previously done separately in
- * jaccardSimilarity and sharedTokenCount).
- */
-function computeSimilarityAndShared(a: string[], b: string[]): { similarity: number; shared: number } {
-  const countA = new Map<string, number>();
-  for (const t of a) countA.set(t, (countA.get(t) ?? 0) + 1);
-
-  let intersection = 0;
-  const seen = new Map<string, number>();
-  for (const t of b) {
-    const limit = countA.get(t) ?? 0;
-    const used = seen.get(t) ?? 0;
-    if (used < limit) {
-      intersection++;
-      seen.set(t, used + 1);
-    }
-  }
-
-  const union = a.length + b.length - intersection;
-  const similarity = union === 0 ? 1 : intersection / union;
-  return { similarity, shared: intersection };
-}
-
-export function detectClones(
-  db: MonographDb,
-  minSimilarity = 0.8,
-  minTokens = 2,
-): CloneDetectionResult {
-  // Query all File nodes with file_path
-  const rows = db
-    .prepare(`SELECT id, file_path FROM nodes WHERE label = 'File' AND file_path IS NOT NULL`)
-    .all() as { id: string; file_path: string }[];
-
-  const totalFiles = rows.length;
-  const pairs: ClonePair[] = [];
-  const involvedFiles = new Set<string>();
-
-  // Pre-compute path tokens and name tokens for each file
-  const tokenMap = new Map<string, { pathTokens: string[]; nameTokens: string[] }>();
-  for (const row of rows) {
-    const pathTokens = tokenizePath(row.file_path);
-    const nameTokens = tokenizePath(baseName(row.file_path));
-    tokenMap.set(row.file_path, { pathTokens, nameTokens });
-  }
-
-  // Compare all pairs
-  for (let i = 0; i < rows.length; i++) {
-    for (let j = i + 1; j < rows.length; j++) {
-      const pathA = rows[i].file_path;
-      const pathB = rows[j].file_path;
-      const entryA = tokenMap.get(pathA)!;
-      const entryB = tokenMap.get(pathB)!;
-
-      const { similarity: sim, shared } = computeSimilarityAndShared(entryA.pathTokens, entryB.pathTokens);
-
-      if (sim < minSimilarity || shared < minTokens) {
-        // Also check near-duplicate file names (same name, different dir)
-        const { similarity: nameSim, shared: nameShared } = computeSimilarityAndShared(entryA.nameTokens, entryB.nameTokens);
-
-        if (nameSim >= minSimilarity && nameShared >= Math.min(minTokens, entryA.nameTokens.length)) {
-          // Same-name files in different directories → structural similarity
-          const pair: ClonePair = {
-            fileA: pathA,
-            fileB: pathB,
-            similarity: nameSim,
-            cloneType: 'structural',
-            tokenCount: nameShared,
-          };
-          pairs.push(pair);
-          involvedFiles.add(pathA);
-          involvedFiles.add(pathB);
-
-          // Emit edge
-          const edgeId = makeId('structurally_similar', rows[i].id, rows[j].id);
-          try {
-            insertEdge(db, {
-              id: edgeId,
-              sourceId: rows[i].id,
-              targetId: rows[j].id,
-              relation: 'STRUCTURALLY_SIMILAR',
-              confidence: 'INFERRED',
-              confidenceScore: nameSim,
-              weight: nameSim,
-            });
-          } catch { /* ignore duplicate edge errors */ }
-        }
-        continue;
-      }
-
-      // Determine clone type
-      let cloneType: ClonePair['cloneType'];
-      if (sim >= 0.99) {
-        cloneType = 'exact';
-      } else if (baseName(pathA) === baseName(pathB)) {
-        cloneType = 'renamed';
-      } else {
-        cloneType = 'structural';
-      }
-
-      const pair: ClonePair = {
-        fileA: pathA,
-        fileB: pathB,
-        similarity: sim,
-        cloneType,
-        tokenCount: shared,
-      };
-      pairs.push(pair);
-      involvedFiles.add(pathA);
-      involvedFiles.add(pathB);
-
-      // Emit STRUCTURALLY_SIMILAR edge into the edges table
-      const edgeId = makeId('structurally_similar', rows[i].id, rows[j].id);
-      try {
-        insertEdge(db, {
-          id: edgeId,
-          sourceId: rows[i].id,
-          targetId: rows[j].id,
-          relation: 'STRUCTURALLY_SIMILAR',
-          confidence: 'INFERRED',
-          confidenceScore: sim,
-          weight: sim,
-        });
-      } catch { /* ignore duplicate edge errors */ }
-    }
-  }
-
-  const cloneRatio = totalFiles === 0 ? 0 : involvedFiles.size / totalFiles;
-
-  return { pairs, totalFiles, cloneRatio };
-}

package/src/graph/shingle-filter.ts

@@ -1,149 +0,0 @@
-export interface ShingleFilter {
-  add(id: string, tokens: string[]): void;
-  candidates(tokens: string[], topK?: number): string[];   // fast pre-filter
-}
-
-/**
- * Generate k-shingles (k-grams) from a token array.
- * Each shingle is the concatenation of k consecutive tokens joined by a space.
- */
-function kShingles(tokens: string[], k: number): string[] {
-  if (tokens.length < k) return [tokens.join(' ')];
-  const shingles: string[] = [];
-  for (let i = 0; i <= tokens.length - k; i++) {
-    shingles.push(tokens.slice(i, i + k).join(' '));
-  }
-  return shingles;
-}
-
-/**
- * Simple string hash that produces a non-negative 32-bit integer.
- * Uses a djb2-style hash.
- */
-function hashString(s: string): number {
-  let h = 5381;
-  for (let i = 0; i < s.length; i++) {
-    h = ((h << 5) + h) ^ s.charCodeAt(i);
-    h = h >>> 0; // keep unsigned 32-bit
-  }
-  return h;
-}
-
-const MINHASH_PRIME = BigInt(4294967311); // first prime > 2^32
-
-/**
- * Compute a MinHash signature for a set of shingles using
- * numHashes linear hash functions: h_i(x) = (a_i * x + b_i) % prime.
- *
- * @param seedsA  Precomputed BigInt a-coefficients (length numHashes)
- * @param seedsB  Precomputed BigInt b-constants   (length numHashes)
- */
-function minHashSignature(
-  shingles: string[],
-  numHashes: number,
-  seedsA: BigInt64Array,
-  seedsB: BigInt64Array,
-): Uint32Array {
-  const sig = new Uint32Array(numHashes).fill(0xffffffff);
-
-  for (const shingle of shingles) {
-    const x = BigInt(hashString(shingle));
-    for (let i = 0; i < numHashes; i++) {
-      // Precomputed seeds avoid recomputing the same (a, b) per shingle per call.
-      const hashVal = Number((seedsA[i]! * x + seedsB[i]!) % MINHASH_PRIME) >>> 0;
-      if (hashVal < sig[i]!) sig[i] = hashVal;
-    }
-  }
-  return sig;
-}
-
-export function createShingleFilter(k = 5, numHashes = 128): ShingleFilter {
-  // Each entry: { sig: Uint32Array }
-  const index = new Map<string, Uint32Array>();
-
-  // LSH: split numHashes into bands of rows
-  // Standard LSH: numBands * numRows = numHashes, threshold ≈ (1/numBands)^(1/numRows)
-  // We target threshold ~0.5: solve (1/b)^(1/r) = 0.5 with b*r = numHashes
-  // A reasonable split is sqrt(numHashes) bands of sqrt(numHashes) rows each.
-  const numBands = Math.round(Math.sqrt(numHashes));
-  const numRows = Math.floor(numHashes / numBands);
-
-  // Precompute MinHash seeds once per filter instance to avoid recomputing
-  // (a, b) inside the hot inner loop of minHashSignature().
-  const seedsA = new BigInt64Array(numHashes);
-  const seedsB = new BigInt64Array(numHashes);
-  for (let i = 0; i < numHashes; i++) {
-    seedsA[i] = BigInt(((i * 2654435761 + 0x9e3779b9) >>> 0));
-    seedsB[i] = BigInt(((i * 2246822519 + 0x85ebca6b) >>> 0));
-  }
-
-  function getBandKey(band: number, sig: Uint32Array): string {
-    const parts: number[] = [];
-    for (let r = 0; r < numRows; r++) {
-      const idx = band * numRows + r;
-      if (idx < numHashes) parts.push(sig[idx]!);
-    }
-    return `b${band}:${parts.join(',')}`;
-  }
-
-  // Band bucket → list of candidate IDs
-  const bandBuckets = new Map<string, string[]>();
-
-  return {
-    add(id: string, tokens: string[]): void {
-      const shingles = kShingles(tokens, k);
-      const sig = minHashSignature(shingles, numHashes, seedsA, seedsB);
-      index.set(id, sig);
-
-      // Insert into LSH band buckets
-      for (let band = 0; band < numBands; band++) {
-        const key = getBandKey(band, sig);
-        const bucket = bandBuckets.get(key);
-        if (bucket) {
-          bucket.push(id);
-        } else {
-          bandBuckets.set(key, [id]);
-        }
-      }
-    },
-
-    candidates(tokens: string[], topK = 10): string[] {
-      const shingles = kShingles(tokens, k);
-      const querySig = minHashSignature(shingles, numHashes, seedsA, seedsB);
-
-      // Collect candidate IDs via LSH band matching.
-      // Use getBandKey() consistently — eliminates the duplicate inline computation.
-      const candidateScores = new Map<string, number>();
-
-      for (let band = 0; band < numBands; band++) {
-        const queryKey = getBandKey(band, querySig);
-        const bucket = bandBuckets.get(queryKey);
-        if (bucket) {
-          for (const id of bucket) {
-            candidateScores.set(id, (candidateScores.get(id) ?? 0) + 1);
-          }
-        }
-      }
-
-      if (candidateScores.size === 0) return [];
-
-      // Compute Jaccard estimate from signature agreement for ranked results
-      const ranked = [...candidateScores.keys()].map(id => {
-        const sig = index.get(id)!;
-        let matches = 0;
-        for (let i = 0; i < numHashes; i++) {
-          if (sig[i] === querySig[i]) matches++;
-        }
-        const jaccardEst = matches / numHashes;
-        return { id, jaccardEst };
-      });
-
-      // Filter by estimated Jaccard > 0.5 and return topK
-      return ranked
-        .filter(r => r.jaccardEst > 0.5)
-        .sort((a, b) => b.jaccardEst - a.jaccardEst)
-        .slice(0, topK)
-        .map(r => r.id);
-    },
-  };
-}