weavatrix 0.3.13 → 1.0.0

package/src/analysis/dependency/scoped-dependencies.js

@@ -1,51 +0,0 @@
-import {posix} from 'node:path'
-
-export const normalizeDependencyScope = (root) => String(root || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/^\/+|\/+$/g, '')
-export const dependencyScopeRoot = (manifest) => {
-    const root = posix.dirname(normalizeDependencyScope(manifest))
-    return root === '.' ? '' : root
-}
-export const dependencyScopeOwnsFile = (scope, file) => !scope || file === scope || String(file || '').startsWith(`${scope}/`)
-
-// Bind the ecosystem-specific core without introducing a facade/helper import cycle.
-export function createScopedDepFindings(computeDepFindings) {
-    return function computeScopedDepFindings({
-        externalImports = [], packageScopes = [], workspacePkgNames = new Set(), configTexts = new Map(),
-        sourceTexts = new Map(), nonRuntimeRoots = [], sourceFiles = [],
-    } = {}) {
-        const scopes = packageScopes.length
-            ? packageScopes.map((scope) => ({...scope, root: normalizeDependencyScope(scope.root)})).sort((a, b) => b.root.length - a.root.length)
-            : [{root: '', manifest: 'package.json', pkg: {}, aliases: []}]
-        const importsByScope = new Map(scopes.map((scope) => [scope, []]))
-        const sourceFilesByScope = new Map(scopes.map((scope) => [scope, []]))
-        const sourceTextsByScope = new Map(scopes.map((scope) => [scope, new Map()]))
-        for (const item of externalImports) {
-            const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, item.file)) || scopes[scopes.length - 1]
-            importsByScope.get(owner).push(item)
-        }
-        for (const file of sourceFiles) {
-            const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, file)) || scopes[scopes.length - 1]
-            sourceFilesByScope.get(owner).push(file)
-        }
-        for (const [file, text] of sourceTexts) {
-            const owner = scopes.find((scope) => dependencyScopeOwnsFile(scope.root, file)) || scopes[scopes.length - 1]
-            sourceTextsByScope.get(owner).set(file, text)
-        }
-        const configOwner = new Map()
-        for (const [file] of configTexts) configOwner.set(file, scopes.find((scope) => dependencyScopeOwnsFile(scope.root, file)) || scopes[scopes.length - 1])
-        const findings = [], usedPackages = new Map(), declared = new Set()
-        for (const scope of scopes) {
-            const scopeConfig = new Map([...configTexts].filter(([file]) => configOwner.get(file) === scope))
-            const result = computeDepFindings({
-                externalImports: importsByScope.get(scope), pkg: scope.pkg || {}, workspacePkgNames,
-                configTexts: scopeConfig, sourceTexts: sourceTextsByScope.get(scope), aliases: scope.aliases || [], scope: scope.root,
-                manifest: scope.manifest || (scope.root ? `${scope.root}/package.json` : 'package.json'),
-                nonRuntimeRoots, sourceFiles: sourceFilesByScope.get(scope),
-            })
-            findings.push(...result.findings)
-            for (const [name, use] of result.usedPackages) usedPackages.set(`${scope.root || '.'}:${name}`, use)
-            for (const name of result.declared) declared.add(`${scope.root || '.'}:${name}`)
-        }
-        return {findings, usedPackages, declared}
-    }
-}

package/src/analysis/dependency/source-references.js

@@ -1,21 +0,0 @@
-// Dynamic package loaders often construct a node_modules path instead of using
-// import/require, so they never become graph externalImports. Restrict this
-// fallback to executable npm source: manifests merely declare every dependency
-// and must never count as usage evidence.
-const NPM_SOURCE_RE = /\.(?:[cm]?[jt]sx?|vue|svelte)$/i
-const escRe = (value) => String(value).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-const mentioned = (blob, name) => new RegExp(`(^|[^\\w@.-])${escRe(name)}($|[^\\w.-])`).test(blob)
-
-export function createPackageSourceMatcher(sourceTexts = new Map()) {
-    const blob = [...sourceTexts]
-        .filter(([file]) => NPM_SOURCE_RE.test(String(file || '')))
-        .map(([, text]) => String(text || ''))
-        .join('\n')
-    return (name) => {
-        if (mentioned(blob, name)) return true
-        if (!name.startsWith('@') || !name.includes('/')) return false
-        const [namespace, base] = name.split('/', 2)
-        // join(root, "node_modules", "@scope", "package", ...)
-        return new RegExp(`["'\x60]${escRe(namespace)}["'\x60][\\s\\S]{0,96}?["'\x60]${escRe(base)}["'\x60]`).test(blob)
-    }
-}

package/src/analysis/duplicate-groups.js

@@ -1,104 +0,0 @@
-import {createHash} from 'node:crypto'
-import {writeFileSync} from 'node:fs'
-import {join} from 'node:path'
-import {computeDuplicates} from './duplicates.js'
-import {withGitRefCheckout} from './git-ref-graph.js'
-import {buildInternalGraph} from '../graph/internal-builder.js'
-import {filterGraphForMode} from '../graph/graph-filter.js'
-
-const NON_PRODUCT = new Set(['generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
-const eligible = (fragment, settings) => {
-  const classes = new Set(fragment.classes || [])
-  if (fragment.n < settings.tokMin) return false
-  if (settings.skipTests && (fragment.test || classes.has('test') || classes.has('e2e'))) return false
-  return settings.includeClassified || !(fragment.excluded || [...classes].some((name) => NON_PRODUCT.has(name)))
-}
-
-function groupPairs(data, settings) {
-  const fragments = data.frags || []
-  const pairs = (data.modes?.[settings.mode] || []).filter(([a, b, similarity]) => similarity >= settings.simMin && eligible(fragments[a], settings) && eligible(fragments[b], settings))
-  const parent = new Map()
-  const find = (value) => { let root = value; while (parent.get(root) !== root) root = parent.get(root); return root }
-  for (const [a, b] of pairs) {
-    if (!parent.has(a)) parent.set(a, a)
-    if (!parent.has(b)) parent.set(b, b)
-    parent.set(find(a), find(b))
-  }
-  const groups = new Map()
-  for (const [a, b, similarity] of pairs) {
-    const root = find(a)
-    if (!groups.has(root)) groups.set(root, {members: new Set(), maxSim: 0})
-    const group = groups.get(root)
-    group.members.add(a); group.members.add(b); group.maxSim = Math.max(group.maxSim, similarity)
-  }
-  return [...groups.values()].map((group) => {
-    const members = [...group.members].map((index) => fragments[index]).sort((a, b) => b.n - a.n)
-    return {members, maxSim: group.maxSim, tokens: members.reduce((sum, item) => sum + item.n, 0)}
-  }).sort((a, b) => b.tokens - a.tokens)
-}
-
-export function isFrameworkBoilerplateCloneGroup(group) {
-  const members = Array.isArray(group?.members) ? group.members : []
-  if (members.length < 2) return false
-  return members.every((member) => /(?:^|\/)\w[^/]*\.router\.[cm]?[jt]s$/i.test(String(member.file || '').replace(/\\/g, '/'))
-    && /^(?:router|routes)\(?\)?$/i.test(String(member.label || '').trim()))
-}
-
-export function isDeclarativeCatalogCloneGroup(group) {
-  const members = Array.isArray(group?.members) ? group.members : []
-  return members.length >= 2 && members.every((member) => member.declarative === true)
-}
-
-export function analyzeDuplicateGroups(repoRoot, graphPath, args = {}) {
-  const settings = {
-    simMin: Math.min(100, Math.max(50, Number(args.min_similarity) || 80)),
-    tokMin: Math.min(400, Math.max(12, Number(args.min_tokens) || 50)),
-    mode: args.mode === 'strict' ? 'strict' : 'renamed',
-    skipTests: args.include_tests !== true,
-    includeClassified: args.include_classified === true || args.include_non_product === true,
-    includeBoilerplate: args.include_boilerplate === true,
-    includeDeclarative: args.include_declarative === true,
-  }
-  const data = computeDuplicates(repoRoot, graphPath, {includeStrings: args.include_strings === true, minTokens: settings.tokMin})
-  const allGroups = groupPairs(data, settings)
-  const afterBoilerplate = settings.includeBoilerplate ? allGroups : allGroups.filter((group) => !isFrameworkBoilerplateCloneGroup(group))
-  const groups = settings.includeDeclarative ? afterBoilerplate : afterBoilerplate.filter((group) => !isDeclarativeCatalogCloneGroup(group))
-  const suppressed = (data.frags || []).filter((fragment) => !eligible(fragment, settings)).length
-  return {
-    settings, groups, suppressed,
-    boilerplateSuppressed: allGroups.length - afterBoilerplate.length,
-    declarativeSuppressed: afterBoilerplate.length - groups.length,
-  }
-}
-
-const digest = (value) => createHash('sha256').update(value).digest('hex').slice(0, 20)
-function groupKey(group, mode) {
-  const members = group.members.map((fragment) => {
-    const fingerprints = Array.isArray(fragment.fp?.[mode]) ? [...fragment.fp[mode]].sort() : []
-    return `${String(fragment.file).replace(/\\/g, '/')}\0${fragment.label || ''}\0${digest(JSON.stringify(fingerprints))}`
-  }).sort()
-  return digest(members.join('\n'))
-}
-
-export async function compareDuplicateGroups({repoRoot, graphPath, currentGraph, baseRef, changedFiles = [], args = {}}) {
-  const current = analyzeDuplicateGroups(repoRoot, graphPath, args)
-  const mode = ['full', 'no-tests', 'tests-only'].includes(currentGraph?.graphBuildMode) ? currentGraph.graphBuildMode : 'full'
-  const baseline = await withGitRefCheckout(repoRoot, baseRef, async (checkout) => {
-    let graph = await buildInternalGraph(checkout)
-    if (mode !== 'full') graph = filterGraphForMode(graph, mode, {repoRoot: checkout})
-    graph.graphBuildMode = mode
-    const baselineGraphPath = join(checkout, '.weavatrix-verified-graph.json')
-    writeFileSync(baselineGraphPath, JSON.stringify(graph))
-    return analyzeDuplicateGroups(checkout, baselineGraphPath, args)
-  })
-  if (!baseline.ok) return {state: 'UNKNOWN', reason: baseline.error, currentGroups: current.groups.length}
-  const baselineKeys = new Set(baseline.value.groups.map((group) => groupKey(group, current.settings.mode)))
-  const changed = new Set(changedFiles.map((file) => String(file).replace(/\\/g, '/')))
-  const added = current.groups.filter((group) => !baselineKeys.has(groupKey(group, current.settings.mode)))
-  const scoped = added.filter((group) => group.members.some((member) => changed.has(String(member.file).replace(/\\/g, '/'))))
-  return {
-    state: scoped.length ? 'BLOCKED' : 'PASS', baseline: {ref: baseline.ref, commit: baseline.commit},
-    currentGroups: current.groups.length, baselineGroups: baseline.value.groups.length, newGroups: added.length,
-    scopedNewGroups: scoped.slice(0, 20).map((group) => ({similarity: group.maxSim, tokens: group.tokens, members: group.members.slice(0, 8).map((item) => ({file: item.file, start: item.start, end: item.end, label: item.label}))})),
-  }
-}

package/src/analysis/duplicates-worker.js

@@ -1,11 +0,0 @@
-// duplicates-worker.js — runs clone detection OFF Electron's main thread (same rationale as
-// graph/build-worker.js: a blocked main event loop freezes every window on Windows). The fingerprint
-// sets never leave the worker; only slim fragment metadata + similarity pairs cross back.
-import { parentPort, workerData } from "node:worker_threads";
-import { computeDuplicates } from "./duplicates.js";
-
-try {
-  parentPort.postMessage(computeDuplicates(workerData.repoPath, workerData.graphJsonPath));
-} catch (e) {
-  parentPort.postMessage({ ok: false, error: (e && e.message) || String(e) });
-}

package/src/analysis/duplicates.compute.js

@@ -1,269 +0,0 @@
-// duplicates.compute.js — fragment extraction, inverted-index pairing, and the computeDuplicates
-// pipeline (split from duplicates.js; see the facade there for the full algorithm overview).
-import { readFileSync } from "node:fs";
-import { createRepoBoundary } from "../repo-path.js";
-import { createPathClassifier, hasPathClass } from "../path-classification.js";
-import { listRepoFiles } from "./internal-audit.collect.js";
-import { stripNonCode, bodyEndLineCount, tokenize, fingerprints, extractLargeStrings } from "./duplicates.tokenize.js";
-
-const FLOOR_TOKENS = 12;   // absolute safety floor; normal scans still default to 30+ tokens
-const FLOOR_SIM = 0.5;     // pairs below this are not reported (UI slider min)
-const MAX_BODY_LINES = 400;
-// File types with no code SYMBOLS to fragment (stylesheets, markup, docs, single-file components). The
-// user still wants them clone-checked ("check the frontend / md too"), so each is sliced into fixed line
-// WINDOWS and each window is fingerprinted like a function body — a duplicated CSS rule block / HTML
-// section / doc passage then clones the same way.
-const WINDOW_EXTS = /\.(css|scss|sass|less|styl|html?|md|markdown|mdx|vue|svelte|astro)$/i;
-const WINDOW_LINES = 24;   // non-overlapping block size for windowed files
-// Asset files are DEDUP-ONLY — they are NOT put in the code graph (that would score md/css as fake
-// "methods" in Health and clutter the GUI board), so the clone scanner finds them by walking the repo.
-const MAX_ASSET_FILES = 4000;
-// Fingerprints shared by MORE than this many fragments are ubiquitous boilerplate and are excluded
-// from BOTH the shared count AND the union (so jaccard stays honest — see pairsForMode). Set well
-// above realistic clone multiplicity: N byte-identical copies each put all their fingerprints in
-// buckets of size N, so the cap must exceed N or the whole clone family is invisible. 120 covers all
-// but pathological mass-duplication; the O(n²) pair work per bucket stays bounded by it.
-const BUCKET_CAP = 120;
-// A clone must share at least this many DISTINCT (non-ubiquitous) fingerprints. Winnowing collapses a
-// UNIFORM repetitive body (a constant table where every line is `KEY: 'VALUE',` → renamed `I: <str>`) to a
-// handful of fingerprints, so two UNRELATED such tables hit 100% renamed Jaccard on ~3-6 shared fingerprints
-// — "same shape, zero shared content". Requiring real shared evidence drops those false positives while a
-// genuine clone (which shares dozens of fingerprints) is untouched.
-const MIN_SHARED_FP = 8;
-
-// Same-name symbols across DIFFERENT files — the semantic complement to token clones. A token clone
-// says "same body"; a name twin with LOW similarity says "same name, different behavior" — the
-// drift-hazard class of duplicate (three divergent uniqueStrings() implementations) that jaccard
-// ranks too low to surface. OOP-generic lifecycle names are stoplisted; interface implementations
-// still appear, so the caller's report keeps neutral wording.
-const TWIN_STOP = new Set(["constructor", "tostring", "valueof", "dispose", "close", "render", "setup", "teardown", "initialize", "destroy", "connect", "disconnect", "update", "reset", "clear", "create", "handle", "execute", "invoke", "main", "start", "stop", "build", "parse", "value", "index"]);
-function computeNameTwins(frags) {
-  const byName = new Map();
-  frags.forEach((f, i) => {
-    if (f.kind === "string") return;
-    const name = String(f.label || "").trim().replace(/\(\)$/, "");
-    if (name.length < 5 || !/^[A-Za-z_$][\w$]*$/.test(name) || TWIN_STOP.has(name.toLowerCase()) || /^do_(?:get|post|put|patch|delete|head|options)$/i.test(name)) return;
-    const key = name.toLowerCase();
-    let a = byName.get(key); if (!a) byName.set(key, (a = []));
-    a.push(i);
-  });
-  const jac = (A, B) => { let inter = 0; for (const h of A) if (B.has(h)) inter++; const u = A.size + B.size - inter; return u ? inter / u : 0; };
-  const out = [];
-  for (const idxs of byName.values()) {
-    const files = new Set(idxs.map((i) => frags[i].file));
-    if (files.size < 2 || idxs.length > 12) continue; // single-file overloads / framework-name explosions
-    let simMin = 1, simMax = 0;
-    const pairs = [];
-    for (let a = 0; a < idxs.length; a++) for (let b = a + 1; b < idxs.length; b++) {
-      if (frags[idxs[a]].file === frags[idxs[b]].file) continue;
-      const s = jac(frags[idxs[a]].fp.renamed, frags[idxs[b]].fp.renamed);
-      if (s < simMin) simMin = s;
-      if (s > simMax) simMax = s;
-      pairs.push({ a: idxs[a], b: idxs[b], similarity: Math.round(s * 100) });
-    }
-    out.push({
-      label: String(frags[idxs[0]].label || "").replace(/\(\)$/, ""), members: idxs, files: files.size,
-      simMin: Math.round(simMin * 100), simMax: Math.round(simMax * 100),
-      pairs,
-      tokens: idxs.reduce((n, i) => n + frags[i].n, 0),
-    });
-  }
-  return out.sort((x, y) => y.tokens - x.tokens).slice(0, 200);
-}
-
-function pairsForMode(frags, mode) {
-  const index = new Map();
-  frags.forEach((f, i) => { for (const h of f.fp[mode]) { let a = index.get(h); if (!a) index.set(h, (a = [])); a.push(i); } });
-  // eff[i] = count of i's fingerprints that sit in NON-ubiquitous buckets. Jaccard's numerator (shared)
-  // and denominator (union) are BOTH computed over this same restricted set, so excluding a boilerplate
-  // fingerprint never deflates similarity — two real clones sharing a widely-repeated preamble still
-  // pair at 100% on their unique bodies, and the sim is a true jaccard, not an under-count.
-  const eff = new Array(frags.length).fill(0);
-  const shared = new Map();
-  for (const arr of index.values()) {
-    if (arr.length > BUCKET_CAP) continue; // ubiquitous k-gram → excluded from count AND size (both sides)
-    for (const idx of arr) eff[idx]++;
-    for (let a = 0; a < arr.length; a++) for (let b = a + 1; b < arr.length; b++) {
-      const key = arr[a] * 1000000 + arr[b]; // frag count is bounded way below 1e6
-      shared.set(key, (shared.get(key) || 0) + 1);
-    }
-  }
-  const pairs = [];
-  for (const [key, count] of shared) {
-    const i = Math.floor(key / 1000000), j = key % 1000000;
-    const union = eff[i] + eff[j] - count;
-    const sim = union > 0 ? count / union : 0;
-    const smallFragment = Math.min(frags[i].n, frags[j].n) < 30;
-    const enoughEvidence = smallFragment
-      ? sim >= 0.95 && count >= 2
-      : count >= MIN_SHARED_FP;
-    if (sim >= FLOOR_SIM && enoughEvidence) pairs.push([i, j, Math.round(sim * 100)]);
-  }
-  return pairs;
-}
-
-// Parse "L<line>" graph symbol locations into per-file ordered symbol lists.
-function symbolRanges(graph) {
-  const byFile = new Map();
-  for (const n of graph.nodes || []) {
-    if (!n.source_file || !String(n.id || "").includes("#")) continue;
-    const line = Number((String(n.source_location || "").match(/L(\d+)/) || [])[1] || 0);
-    if (!line) continue;
-    let arr = byFile.get(n.source_file);
-    if (!arr) byFile.set(n.source_file, (arr = []));
-    arr.push({ id: n.id, label: n.label || n.id, line, symbolKind: n.symbol_kind || "", testSurface: n.test_surface === true });
-  }
-  for (const arr of byFile.values()) arr.sort((a, b) => a.line - b.line);
-  return byFile;
-}
-
-function loadGraph(graphInput) {
-  if (graphInput && typeof graphInput === "object" && !Array.isArray(graphInput)) {
-    return { nodes: Array.isArray(graphInput.nodes) ? graphInput.nodes : [] };
-  }
-  if (typeof graphInput !== "string" || !graphInput) throw new TypeError("graph path or graph object is required");
-  const parsed = JSON.parse(readFileSync(graphInput, "utf8"));
-  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new TypeError("graph must be an object");
-  return { nodes: Array.isArray(parsed.nodes) ? parsed.nodes : [] };
-}
-
-export function computeDuplicates(repoPath, graphJsonPath, opts = {}) {
-  const includeStrings = !!opts.includeStrings;
-  const scanTokenFloor = Math.max(FLOOR_TOKENS, Math.min(400, Number(opts.minTokens) || 30));
-  const graph = loadGraph(graphJsonPath);
-  const byFile = symbolRanges(graph);
-  // total symbol nodes in the graph — 0 means a file-only graph (built by an older builder before
-  // symbol extraction, or a stale graph): clone detection has nothing to work with, and the UI must
-  // say "rebuild the graph" instead of the misleading "no clones at these thresholds".
-  const repoFiles = listRepoFiles(repoPath);
-  const allowedFiles = new Set(repoFiles);
-  let graphSymbols = 0;
-  for (const [file, arr] of byFile) if (allowedFiles.has(file)) graphSymbols += arr.length;
-  const frags = [];
-  const boundary = createRepoBoundary(repoPath);
-  const classifier = createPathClassifier(repoPath);
-  const classificationByFile = new Map();
-  const classify = (file, content) => {
-    if (!classificationByFile.has(file)) classificationByFile.set(file, classifier.explain(file, { content }));
-    return classificationByFile.get(file);
-  };
-  const classificationFields = (info) => ({
-    test: hasPathClass(info, "test", "e2e"),
-    classes: info.classes,
-    excluded: info.excluded,
-    matchedRule: info.matchedRule,
-  });
-  for (const [file, syms] of byFile) {
-    if (!allowedFiles.has(file)) continue;
-    const resolved = boundary.resolve(file);
-    if (!resolved.ok) continue;
-    const full = resolved.path;
-    let lines;
-    try { lines = readFileSync(full, "utf8").split(/\r?\n/); } catch { continue; }
-    const py = /\.py$/i.test(file);
-    const pathInfo = classify(file, lines.join("\n"));
-    for (let i = 0; i < syms.length; i++) {
-      const start = syms[i].line;
-      // hard cap first (next symbol, or EOF, whichever comes first, ≤ MAX_BODY_LINES) …
-      const hardEnd = Math.min(i + 1 < syms.length ? syms[i + 1].line - 1 : lines.length, start + MAX_BODY_LINES);
-      if (hardEnd - start < 2) continue; // one-liners can't be meaningful clones
-      // … then shrink to where the construct actually closes, so the last symbol doesn't absorb
-      // trailing module-level code (module.exports tables, main() calls) up to EOF.
-      const bodyLines = lines.slice(start - 1, hardEnd);
-      const body = bodyLines.slice(0, bodyEndLineCount(bodyLines, py));
-      const end = start + body.length - 1;
-      if (end - start < 2) continue;
-      const toks = tokenize(stripNonCode(body.join("\n"), py));
-      if (toks.strict.length < scanTokenFloor) continue;
-      const strippedBody = stripNonCode(body.join("\n"), py);
-      const declarativeValue = /^(?:export\s+)?(?:const|let|var)\s+[\w$]+(?:\s*:[^=]+)?\s*=\s*(?:Object\.(?:freeze|seal)\s*\(\s*)?[\[{]/s.test(strippedBody.trim())
-        && !/=>|\b(?:function|if|for|while|switch|try|await|yield|return|throw|new)\b/.test(strippedBody);
-      const declarativeFactory = /^(?:export\s+)?const\s+[\w$]+(?:\s*:[^=]+)?\s*=\s*(?:sqliteTable|pgTable|mysqlTable)\s*\(/s.test(strippedBody.trim());
-      const declarative = declarativeValue || declarativeFactory || /^(?:interface|type|enum)$/i.test(syms[i].symbolKind);
-      frags.push({
-        id: syms[i].id, label: syms[i].label, file, start, end,
-        n: toks.strict.length, declarative,
-        ...classificationFields(pathInfo),
-        // Inline test surfaces (Rust `#[cfg(test)] mod tests`, `#[test]` fns) live in production files, so a
-        // path check alone misses them; the graph already flags the symbol. OR it in so skip-tests suppresses
-        // them by default and two #[test] fns are never reported as a production clone.
-        test: hasPathClass(pathInfo, "test", "e2e") || syms[i].testSurface === true,
-        fp: { strict: fingerprints(toks.strict), renamed: fingerprints(toks.renamed) },
-      });
-    }
-    // ---- opt-in: large multi-line string literals as their own fragments. The code pass above strips
-    // string bodies (correctly — content isn't code), which makes embedded DSL templates (inline
-    // C#/SQL/PowerShell) invisible to clone detection. Tokenized RAW: the content IS the payload.
-    if (includeStrings) {
-      const base = file.split("/").pop();
-      const pushStr = (startLine, endLine, content) => {
-        const toks = tokenize(content);
-        if (toks.strict.length < scanTokenFloor) return;
-        frags.push({
-          id: `${file}#str@${startLine}`, label: `${base}:${startLine} ~${endLine - startLine + 1}-line string`,
-          file, start: startLine, end: endLine, n: toks.strict.length, ...classificationFields(pathInfo), kind: "string",
-          fp: { strict: fingerprints(toks.strict), renamed: fingerprints(toks.renamed) },
-        });
-      };
-      for (const str of extractLargeStrings(lines.join("\n"), { py, cs: /\.cs$/i.test(file) })) {
-        const strLines = str.content.split(/\r?\n/).slice(0, MAX_BODY_LINES);
-        // A SECTION shared between two big templates dilutes below the similarity floor when the whole
-        // literals are compared (70 shared lines inside 220- and 107-line strings ≈ 27% jaccard). Big
-        // literals therefore get the same WINDOW treatment as CSS/HTML files; small ones stay whole.
-        if (strLines.length <= WINDOW_LINES * 2) {
-          pushStr(str.start, str.start + strLines.length - 1, strLines.join("\n"));
-        } else {
-          for (let off = 0; off < strLines.length; off += WINDOW_LINES) {
-            const chunk = strLines.slice(off, off + WINDOW_LINES);
-            if (chunk.length < 3) break;
-            pushStr(str.start + off, str.start + off + chunk.length - 1, chunk.join("\n"));
-          }
-        }
-      }
-    }
-  }
-  // ---- windowed fragments for symbol-less file types (CSS/HTML/MD/…), found by walking the repo (NOT the
-  // graph — assets are dedup-only). Each file is sliced into WINDOW_LINES blocks and fingerprinted.
-  const symFiles = new Set(byFile.keys());
-  const allAssetFiles = repoFiles.filter((file) => WINDOW_EXTS.test(file));
-  const assetFiles = allAssetFiles.slice(0, MAX_ASSET_FILES);
-  for (const file of assetFiles) {
-    if (symFiles.has(file)) continue;
-    const resolved = boundary.resolve(file);
-    if (!resolved.ok) continue;
-    let lines;
-    try { lines = readFileSync(resolved.path, "utf8").split(/\r?\n/); } catch { continue; }
-    const pathInfo = classify(file, lines.join("\n"));
-    for (let start = 1; start <= lines.length; start += WINDOW_LINES) {
-      const end = Math.min(start + WINDOW_LINES - 1, lines.length);
-      if (end - start < 2) continue;
-      const toks = tokenize(stripNonCode(lines.slice(start - 1, end).join("\n"), false));
-      if (toks.strict.length < scanTokenFloor) continue;
-      frags.push({
-        id: `${file}#win@${start}`, label: `${file.split("/").pop()}:${start}-${end}`, file, start, end,
-        n: toks.strict.length, ...classificationFields(pathInfo),
-        fp: { strict: fingerprints(toks.strict), renamed: fingerprints(toks.renamed) },
-      });
-    }
-  }
-  const modes = { strict: pairsForMode(frags, "strict"), renamed: pairsForMode(frags, "renamed") };
-  const nameTwins = opts.nameTwins ? computeNameTwins(frags) : null;
-  // fp sets are worker-internal — strip them from the payload that crosses the thread boundary
-  const slim = frags.map(({ fp, ...rest }) => rest);
-  return {
-    ok: true,
-    frags: slim,
-    modes,
-    ...(nameTwins ? { nameTwins } : {}),
-    graphSymbols,
-    completeness: {
-      assetFiles: {
-        total: allAssetFiles.length,
-        scanned: assetFiles.length,
-        truncated: allAssetFiles.length > assetFiles.length,
-      },
-      nameTwinsTruncated: !!nameTwins && nameTwins.length >= 200,
-    },
-    floors: { tokens: scanTokenFloor, absoluteTokens: FLOOR_TOKENS, sim: FLOOR_SIM * 100 },
-  };
-}

package/src/analysis/duplicates.js

@@ -1,15 +0,0 @@
-// duplicates.js — content-based clone detection over the repo's OWN graph.json symbols (the Health
-// tab's engine). MOSS-style pipeline: symbol bodies (line ranges from the graph) → strip comments &
-// string bodies → tokenize → k-gram rolling hashes → winnowing fingerprints → inverted index (no
-// O(n²) all-pairs) → jaccard similarity. BOTH normalization modes are computed in one pass so every
-// UI knob (similarity %, min size, strict/renamed) filters instantly on the renderer side:
-//   strict  — identifiers kept: only literal copy-paste (Type-1 clones)
-//   renamed — identifiers canonicalized to "I": catches copy-paste-then-rename (Type-2 clones)
-// Pairs are reported down to the FLOOR values; the renderer slices from there upward.
-//
-// Facade: the implementation lives in the sibling modules —
-//   duplicates.tokenize.js — stripping, body-end detection, tokenization, winnowing fingerprints
-//   duplicates.compute.js  — fragment extraction, inverted-index pairing, computeDuplicates
-//   duplicates.run.js      — worker offload + mtime cache (runDuplicates entry)
-export { computeDuplicates } from "./duplicates.compute.js";
-export { runDuplicates } from "./duplicates.run.js";

package/src/analysis/duplicates.run.js

@@ -1,52 +0,0 @@
-// duplicates.run.js — the repos:duplicates entry point (split from duplicates.js): worker-thread
-// offload with in-process fallback, cached per (repo, graph.json mtime).
-import { existsSync, statSync } from "node:fs";
-import { join } from "node:path";
-import { Worker } from "node:worker_threads";
-import { childProcessEnv } from "../child-env.js";
-import { graphOutDirForRepo } from "../graph/layout.js";
-import { computeDuplicates } from "./duplicates.compute.js";
-
-function computeInWorker(repoPath, graphJsonPath) {
-  return new Promise((resolve, reject) => {
-    let worker;
-    try {
-      worker = new Worker(new URL("./duplicates-worker.js", import.meta.url), { workerData: { repoPath, graphJsonPath }, env: childProcessEnv() });
-    } catch (e) {
-      reject(Object.assign(e, { workerStartFailed: true }));
-      return;
-    }
-    let settled = false;
-    const done = (fn, v) => { if (!settled) { settled = true; fn(v); } };
-    worker.once("message", (msg) => done(resolve, msg));
-    worker.once("error", (e) => done(reject, Object.assign(e, { workerStartFailed: true })));
-    worker.once("exit", (code) => { if (code !== 0) done(reject, Object.assign(new Error(`duplicates worker exited with code ${code}`), { workerStartFailed: true })); });
-  });
-}
-
-// repos:duplicates entry — cached per (repo, graph.json mtime): re-running with an unchanged graph is
-// free. `force` (the UI's ↻ rescan) bypasses the cache: fragment BODIES are read from live source, so a
-// source edit that didn't rebuild the graph (same mtime) must still be re-scanned on demand.
-const _cache = new Map();
-export async function runDuplicates(repoPath, force = false) {
-  const repo = String(repoPath || "");
-  if (!repo || !existsSync(repo)) return { ok: false, error: "Repo path not found" };
-  const graphJsonPath = join(graphOutDirForRepo(repo), "graph.json");
-  if (!existsSync(graphJsonPath)) {
-    return { ok: false, needsGraph: true, error: "No graph yet — build the Relations graph first (↻ on the Relations tab)" };
-  }
-  let mtime = 0;
-  try { mtime = statSync(graphJsonPath).mtimeMs; } catch { /* treat as uncached */ }
-  const cached = _cache.get(repo);
-  if (!force && cached && cached.mtime === mtime) return cached.result;
-  let result;
-  try {
-    result = await computeInWorker(repo, graphJsonPath);
-  } catch (e) {
-    if (!e || !e.workerStartFailed) return { ok: false, error: e.message || String(e) };
-    try { result = computeDuplicates(repo, graphJsonPath); } // in-process fallback (exotic packaging)
-    catch (e2) { return { ok: false, error: e2.message || String(e2) }; }
-  }
-  if (result && result.ok) _cache.set(repo, { mtime, result });
-  return result;
-}