@monoes/monograph 1.5.2 → 1.5.4

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);
-    },
-  };
-}

package/src/watch/watch-runner.ts

@@ -1,64 +0,0 @@
-import { extname, basename, relative } from 'node:path';
-
-const SOURCE_EXTENSIONS = new Set([
-  'ts','tsx','mts','cts','js','jsx','mjs','cjs',
-  'vue','svelte','astro','mdx','css','scss',
-]);
-
-const CONFIG_FILENAMES = new Set([
-  'package.json', '.fallowrc.json', '.fallowrc.jsonc',
-  'fallow.toml', '.fallow.toml', 'tsconfig.json',
-  'monograph.json', 'monograph.config.json', '.monographrc.json',
-]);
-
-export function isRelevantSource(filePath: string): boolean {
-  const ext = extname(filePath).replace('.', '');
-  return SOURCE_EXTENSIONS.has(ext);
-}
-
-export function isRelevantConfig(filePath: string): boolean {
-  return CONFIG_FILENAMES.has(basename(filePath));
-}
-
-export function collectChangedPaths(rawPaths: string[], root: string): string[] {
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const p of rawPaths) {
-    if (!isRelevantSource(p) && !isRelevantConfig(p)) continue;
-    const rel = relative(root, p);
-    if (!seen.has(rel)) { seen.add(rel); result.push(rel); }
-  }
-  return result;
-}
-
-export interface WatchRunnerOptions {
-  root: string;
-  noCache?: boolean;
-  quiet?: boolean;
-  clearScreen?: boolean;
-  debounceMs?: number;
-  includeEntryExports?: boolean;
-  onAnalysis: (changedPaths: string[]) => Promise<void>;
-  loadConfig: () => Promise<unknown>;
-}
-
-export async function reloadConfigOrKeepPrevious<T>(
-  current: T,
-  loader: () => Promise<T>,
-  onError?: (err: unknown) => void,
-): Promise<T> {
-  try {
-    return await loader();
-  } catch (err) {
-    onError?.(err);
-    return current;
-  }
-}
-
-export function debounce<T extends (...args: unknown[]) => void>(fn: T, ms: number): T {
-  let timer: ReturnType<typeof setTimeout> | null = null;
-  return ((...args: unknown[]) => {
-    if (timer !== null) clearTimeout(timer);
-    timer = setTimeout(() => { timer = null; fn(...args); }, ms);
-  }) as T;
-}