weavatrix 0.3.13 → 1.0.0

package/src/analysis/change-classification/options.js

@@ -1,40 +0,0 @@
-export const CHANGE_CLASSIFICATION_LIMITS = Object.freeze({
-    maxDiffBytes: 2 * 1024 * 1024,
-    maxFiles: 500,
-    maxChangedLines: 20_000,
-    maxLineLength: 4_000,
-    maxSymbolsPerFile: 250,
-    maxSeeds: 1_000,
-})
-
-export const CHANGE_CLASS_RANK = Object.freeze({
-    'metadata-only': 0,
-    'test-only': 0,
-    added: 1,
-    'body-changed': 2,
-    'signature-changed': 3,
-    removed: 4,
-    unknown: 5,
-})
-
-export const normalizeChangePath = (value) => String(value || '').replace(/\\/g, '/').replace(/^\.\//, '')
-export const changeLineNumber = (value) => Number((String(value || '').match(/(?:^L|@)(\d+)$/) || [])[1] || 0)
-export const bareGraphLabel = (value) => String(value || '').replace(/\(.*$/, '').replace(/[^A-Za-z0-9_$].*$/, '').trim()
-
-export function changeLimits(value = {}) {
-    const bounded = (item, fallback, min, max) => Math.max(min, Math.min(max, Number(item) || fallback))
-    const defaults = CHANGE_CLASSIFICATION_LIMITS
-    return {
-        maxDiffBytes: bounded(value.maxDiffBytes, defaults.maxDiffBytes, 1_024, defaults.maxDiffBytes),
-        maxFiles: bounded(value.maxFiles, defaults.maxFiles, 1, defaults.maxFiles),
-        maxChangedLines: bounded(value.maxChangedLines, defaults.maxChangedLines, 10, defaults.maxChangedLines),
-        maxLineLength: bounded(value.maxLineLength, defaults.maxLineLength, 80, defaults.maxLineLength),
-        maxSymbolsPerFile: bounded(value.maxSymbolsPerFile, defaults.maxSymbolsPerFile, 1, defaults.maxSymbolsPerFile),
-        maxSeeds: bounded(value.maxSeeds, defaults.maxSeeds, 1, defaults.maxSeeds),
-    }
-}
-
-export function uniqueChangeSeeds(values, limit) {
-    const all = [...new Set(values.filter(Boolean).map(String))].sort((a, b) => a.localeCompare(b))
-    return {items: all.slice(0, limit), truncated: all.length > limit, total: all.length}
-}

package/src/analysis/change-classification/symbol-classifier.js

@@ -1,177 +0,0 @@
-import {hasPathClass} from '../../path-classification.js'
-import {bareGraphLabel, CHANGE_CLASS_RANK, changeLineNumber, normalizeChangePath} from './options.js'
-
-export function indexChangeGraph(graph, limits) {
-    const byFile = new Map()
-    for (const node of graph?.nodes || []) {
-        const file = normalizeChangePath(node?.source_file || (!String(node?.id || '').includes('#') ? node?.id : ''))
-        if (!file) continue
-        if (!byFile.has(file)) byFile.set(file, {path: file, fileNodeId: null, symbols: []})
-        const record = byFile.get(file)
-        if (!String(node.id).includes('#')) record.fileNodeId = String(node.id)
-        else if (record.symbols.length < limits.maxSymbolsPerFile) {
-            const start = changeLineNumber(node.source_location) || changeLineNumber(node.id)
-            if (!start) continue
-            record.symbols.push({
-                id: String(node.id), label: String(node.label || node.id), start,
-                end: changeLineNumber(node.source_end), exported: node.exported === true,
-                symbolKind: node.symbol_kind || null,
-            })
-        }
-    }
-    for (const record of byFile.values()) {
-        record.symbols.sort((a, b) => a.start - b.start || a.id.localeCompare(b.id))
-        for (let index = 0; index < record.symbols.length; index++) {
-            const symbol = record.symbols[index]
-            if (!symbol.end || symbol.end < symbol.start) {
-                const next = record.symbols[index + 1]?.start
-                symbol.end = next ? Math.max(symbol.start, next - 1) : symbol.start + 400
-            }
-            symbol.end = Math.min(symbol.end, symbol.start + 2_000)
-        }
-    }
-    return byFile
-}
-
-const isMetadataLine = (text) => {
-    const value = String(text || '').trim()
-    return !value || /^(?:\/\/|\/\*|\*|\*\/|#(?!include\b)|<!--|-->|"""|''')/.test(value)
-}
-
-function signatureText(text, symbol) {
-    const value = String(text || '').trim(), name = bareGraphLabel(symbol.label)
-    const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-    const hasName = name && new RegExp(`\\b${escaped}\\b`, 'i').test(value)
-    return hasName && /\b(?:export|default|declare|abstract|async|function|class|interface|type|enum|const|let|var|def|func|fn|struct|trait|impl|public|private|protected|static)\b/.test(value)
-}
-
-function signaturePosition(change, symbol) {
-    const candidates = change.kind === 'removed' ? [change.mappedNewLine, change.oldLine] : [change.newLine]
-    if (candidates.some((line) => line === symbol.start)) return true
-    if (!candidates.some((line) => Number.isFinite(line) && line > symbol.start && line <= symbol.start + 4)) return false
-    const value = String(change.text || '').trim()
-    if (/^(?:return|throw|yield|if|for|while|switch|match|const|let|var|this\.|self\.|[A-Za-z_$][\w$]*\s*=)/.test(value)) return false
-    return /^(?:[A-Za-z_$][\w$]*\??\s*:\s*[^;]+[,)]?|[A-Za-z_$][\w$<>,.?\[\] :*&]+\s+[A-Za-z_$][\w$]*\s*[,)]|[),:<>{}\[\]|&?]+)$/.test(value)
-}
-
-const moduleSignatureText = (text) => /^\s*(?:import\b|export\s+(?:\*|\{)|(?:const|let|var)\s+\w+\s*=\s*require\b|using\b|package\b|#include\b|mod\b|pub\s+use\b)/.test(String(text || ''))
-
-function chooseSymbol(record, change) {
-    if (!record?.symbols?.length) return null
-    const lines = change.kind === 'removed'
-        ? [...new Set([change.mappedNewLine, change.oldLine].filter((line) => Number.isFinite(line) && line > 0))]
-        : [change.newLine]
-    const candidates = []
-    for (const symbol of record.symbols) {
-        if (!lines.some((line) => line >= symbol.start && line <= symbol.end)) continue
-        const label = bareGraphLabel(symbol.label)
-        const escaped = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
-        candidates.push({symbol, mentions: label && new RegExp(`\\b${escaped}\\b`).test(change.text), span: symbol.end - symbol.start})
-    }
-    return candidates.sort((a, b) => Number(b.mentions) - Number(a.mentions) || a.span - b.span || a.symbol.id.localeCompare(b.symbol.id))[0]?.symbol || null
-}
-
-const strongest = (classes) => [...classes]
-    .sort((a, b) => (CHANGE_CLASS_RANK[b] ?? 5) - (CHANGE_CLASS_RANK[a] ?? 5) || a.localeCompare(b))[0] || 'metadata-only'
-
-function symbolChanges(parsed, record, includeAddedSeeds) {
-    const grouped = new Map(), unmapped = []
-    for (const change of [...parsed.additions, ...parsed.removals]) {
-        const symbol = chooseSymbol(record, change)
-        if (!symbol) { unmapped.push(change); continue }
-        if (!grouped.has(symbol.id)) grouped.set(symbol.id, {symbol, additions: [], removals: []})
-        grouped.get(symbol.id)[change.kind === 'added' ? 'additions' : 'removals'].push(change)
-    }
-    const symbols = [], seedIds = []
-    for (const group of [...grouped.values()].sort((a, b) => a.symbol.start - b.symbol.start || a.symbol.id.localeCompare(b.symbol.id))) {
-        const addedCode = group.additions.filter((change) => !isMetadataLine(change.text))
-        const removedCode = group.removals.filter((change) => !isMetadataLine(change.text))
-        const addedDeclaration = addedCode.some((change) => signaturePosition(change, group.symbol) || signatureText(change.text, group.symbol))
-        const removedDeclaration = removedCode.some((change) => signaturePosition(change, group.symbol) || signatureText(change.text, group.symbol))
-        let classification
-        if (parsed.newFile || (addedDeclaration && !removedCode.length)) classification = 'added'
-        else if (parsed.deletedFile || (removedDeclaration && !addedCode.length)) classification = 'removed'
-        else if (addedDeclaration || removedDeclaration) classification = 'signature-changed'
-        else if (addedCode.length || removedCode.length) classification = 'body-changed'
-        else classification = 'metadata-only'
-        const reasons = {
-            added: 'new declaration; existing callers cannot depend on it yet',
-            removed: 'declaration removed; existing callers may break',
-            'signature-changed': 'declaration/signature line changed',
-            'body-changed': 'executable lines changed inside the symbol body',
-            'metadata-only': 'only comment/blank lines changed in this symbol',
-        }
-        const symbolSeeds = []
-        if (classification === 'added') { if (includeAddedSeeds) symbolSeeds.push(group.symbol.id) }
-        else if (classification !== 'metadata-only') {
-            symbolSeeds.push(group.symbol.id)
-            if (['removed', 'signature-changed'].includes(classification) && group.symbol.exported && record?.fileNodeId) symbolSeeds.push(record.fileNodeId)
-        }
-        seedIds.push(...symbolSeeds)
-        symbols.push({
-            id: group.symbol.id, label: group.symbol.label, start: group.symbol.start, end: group.symbol.end,
-            exported: group.symbol.exported, classification, reason: reasons[classification],
-            addedLines: group.additions.map((change) => change.newLine).filter(Boolean),
-            removedLines: group.removals.map((change) => change.oldLine).filter(Boolean),
-            seedIds: [...new Set(symbolSeeds)].sort(),
-        })
-    }
-    return {symbols, seedIds, unmapped}
-}
-
-export function analyzeParsedFile(parsed, indexed, {includeAddedSeeds}) {
-    const path = parsed.newPath || parsed.oldPath || '(unknown)'
-    const record = indexed.get(parsed.newPath) || indexed.get(parsed.oldPath) || null
-    const grouped = symbolChanges(parsed, record, includeAddedSeeds)
-    const unmappedCode = grouped.unmapped.filter((change) => !isMetadataLine(change.text))
-    const unmappedMetadata = grouped.unmapped.length > 0 && !unmappedCode.length
-    let classification, reason
-    if (parsed.binary) { classification = 'unknown'; reason = 'binary diff has no line-level evidence' }
-    else if (parsed.deletedFile) { classification = 'removed'; reason = 'file removed' }
-    else if (parsed.renamed) { classification = 'signature-changed'; reason = 'file rename changes module identity' }
-    else if (parsed.newFile) { classification = 'added'; reason = 'new file; no existing dependent can target it yet' }
-    else if (unmappedCode.some((change) => moduleSignatureText(change.text))) { classification = 'signature-changed'; reason = 'module import/export surface changed outside a mapped symbol' }
-    else if (unmappedCode.length) { classification = 'unknown'; reason = 'executable diff lines could not be mapped to a graph symbol' }
-    else if (grouped.symbols.length) {
-        classification = strongest(grouped.symbols.map((symbol) => symbol.classification))
-        reason = grouped.symbols.length === 1 ? grouped.symbols[0].reason : `${grouped.symbols.length} mapped symbols; strongest change is ${classification}`
-    } else if (unmappedMetadata || parsed.hunks.length || parsed.additions.length || parsed.removals.length) {
-        classification = 'metadata-only'; reason = 'only comment/blank metadata changed outside symbols'
-    } else { classification = 'metadata-only'; reason = 'file metadata changed without textual hunks' }
-
-    const seedIds = grouped.seedIds
-    if (parsed.binary || parsed.deletedFile || parsed.renamed || classification === 'unknown') {
-        if (record?.fileNodeId) seedIds.push(record.fileNodeId)
-        if (parsed.binary || parsed.deletedFile || classification === 'unknown') seedIds.push(...(record?.symbols || []).map((symbol) => symbol.id))
-    } else if (classification === 'signature-changed' && !grouped.symbols.length && record?.fileNodeId) seedIds.push(record.fileNodeId)
-    else if (classification === 'added' && includeAddedSeeds) {
-        if (record?.fileNodeId) seedIds.push(record.fileNodeId)
-        seedIds.push(...grouped.symbols.map((symbol) => symbol.id))
-    }
-    return {
-        path, oldPath: parsed.oldPath, newPath: parsed.newPath, classification, reason,
-        binary: parsed.binary, renamed: parsed.renamed,
-        addedLines: parsed.additions.length, removedLines: parsed.removals.length,
-        symbols: grouped.symbols, seedIds: [...new Set(seedIds)].sort(),
-    }
-}
-
-export function unknownChangedFile(path, indexed, reason) {
-    const normalized = normalizeChangePath(path), record = indexed.get(normalized)
-    return {
-        path: normalized, oldPath: normalized, newPath: normalized, classification: 'unknown', reason,
-        binary: false, renamed: false, addedLines: 0, removedLines: 0, symbols: [],
-        seedIds: [record?.fileNodeId, ...(record?.symbols || []).map((symbol) => symbol.id)].filter(Boolean).sort(),
-    }
-}
-
-export function classifyTestSurface(file, pathClassifier) {
-    const explanation = pathClassifier.explain(file.path)
-    if (!hasPathClass(explanation, 'test', 'e2e')) return file
-    const surface = explanation.classes.includes('e2e') ? 'e2e' : 'test'
-    return {
-        ...file, classification: 'test-only', changeClassification: file.classification,
-        reason: `${surface} path; excluded from the product blast-radius seed set`,
-        pathClasses: explanation.classes, seedIds: [],
-    }
-}

package/src/analysis/change-classification.js

@@ -1,188 +0,0 @@
-// Symbol-aware git-diff classification for change_impact.
-import {runGit} from '../git-exec.js'
-import {createPathClassifier} from '../path-classification.js'
-import {parseZeroContextDiff} from './change-classification/diff-parser.js'
-import {
-    CHANGE_CLASSIFICATION_LIMITS,
-    CHANGE_CLASS_RANK,
-    changeLimits,
-    normalizeChangePath,
-    uniqueChangeSeeds,
-} from './change-classification/options.js'
-import {
-    analyzeParsedFile,
-    classifyTestSurface,
-    indexChangeGraph,
-    unknownChangedFile,
-} from './change-classification/symbol-classifier.js'
-
-export {parseZeroContextDiff} from './change-classification/diff-parser.js'
-export {CHANGE_CLASSIFICATION_LIMITS} from './change-classification/options.js'
-
-const VERDICT_RANK = Object.freeze({LOW: 0, MEDIUM: 1, HIGH: 2})
-
-function recoverBoundedDiff(repoRoot, base, files, limits) {
-    const deadline = Date.now() + 12_000
-    let text = ''
-    const fallbackFiles = []
-    for (let index = 0; index < files.length; index++) {
-        const remainingMs = deadline - Date.now()
-        const remainingBytes = limits.maxDiffBytes - Buffer.byteLength(text)
-        if (remainingMs <= 0 || remainingBytes < 1_024) {
-            fallbackFiles.push(...files.slice(index))
-            break
-        }
-        const result = runGit(repoRoot, [
-            'diff', '--no-ext-diff', '--find-renames', '--no-color',
-            '--unified=0', String(base), '--', files[index],
-        ], {timeout: Math.min(2_000, remainingMs), maxBuffer: remainingBytes + 1})
-        const chunk = String(result.stdout || '')
-        if (result.status !== 0 || !chunk || Buffer.byteLength(chunk) > remainingBytes) {
-            fallbackFiles.push(files[index])
-            continue
-        }
-        text += chunk
-    }
-    return {text, fallbackFiles}
-}
-
-function runGitDiff(repoRoot, base, limits) {
-    const args = ['diff', '--no-ext-diff', '--find-renames', '--no-color', '--unified=0', String(base), '--']
-    const result = runGit(repoRoot, args, {timeout: 12_000, maxBuffer: limits.maxDiffBytes + 1})
-    const output = String(result.stdout || '')
-    const oversized = result.error?.code === 'ENOBUFS' || Buffer.byteLength(output) > limits.maxDiffBytes
-    if (result.status === 0 && !oversized) return {available: true, text: output, error: null}
-    let fallbackFiles = []
-    let fallbackTruncated = false
-    let recoveredText = ''
-    if (oversized) {
-        const names = runGit(repoRoot, [
-            'diff', '--name-only', '-z', '--no-ext-diff', '--find-renames', String(base), '--',
-        ], {timeout: 12_000, maxBuffer: Math.max(64 * 1024, limits.maxFiles * 4_096)})
-        if (names.status === 0) {
-            const all = String(names.stdout || '').split('\0').map(normalizeChangePath).filter(Boolean)
-            const boundedFiles = [...new Set(all)].sort((a, b) => a.localeCompare(b)).slice(0, limits.maxFiles)
-            fallbackTruncated = all.length > limits.maxFiles
-            const recovered = recoverBoundedDiff(repoRoot, base, boundedFiles, limits)
-            recoveredText = recovered.text
-            fallbackFiles = recovered.fallbackFiles
-        }
-    }
-    return {
-        available: recoveredText.length > 0,
-        text: recoveredText,
-        oversized,
-        partialFallback: recoveredText.length > 0,
-        fallbackFiles,
-        fallbackTruncated,
-        error: oversized
-            ? 'git diff exceeded the byte limit'
-            : String(result.stderr || result.error?.message || 'git diff unavailable').trim(),
-    }
-}
-
-const validExplicitFiles = (files) => [...new Set((Array.isArray(files) ? files : [])
-    .map(normalizeChangePath)
-    .filter((file) => file && !file.startsWith('../') && !file.includes('/../') && !file.startsWith('-')))]
-    .sort((a, b) => a.localeCompare(b))
-
-function collectDiffInput({diffText, repoRoot, base, explicitFiles, limits}) {
-    if (typeof diffText === 'string') return {source: 'provided-diff', available: true, text: diffText, reason: '', oversized: false}
-    if (repoRoot && base) {
-        const result = runGitDiff(repoRoot, base, limits)
-        return {
-            source: 'git-diff', available: result.available, text: result.text,
-            reason: result.error || '', oversized: result.oversized === true,
-            fallbackFiles: result.fallbackFiles || [], fallbackTruncated: result.fallbackTruncated === true,
-            partialFallback: result.partialFallback === true,
-        }
-    }
-    return {
-        source: 'files-only', available: false, text: '', oversized: false,
-        reason: 'no unified diff was provided and no repoRoot/base pair was available',
-        fallbackFiles: [], fallbackTruncated: false, partialFallback: false,
-    }
-}
-
-function classificationReasons(counts, {available, unavailableReason, truncated, includeAddedSeeds}) {
-    const reasons = []
-    if (!available) reasons.push(`Diff unavailable: ${unavailableReason || 'unknown error'}; using conservative file/symbol seeds.`)
-    if (truncated) reasons.push('Diff exceeded a safety bound; incomplete evidence is classified HIGH/unknown.')
-    if (counts.removed || counts['signature-changed']) reasons.push(`${counts.removed} removed and ${counts['signature-changed']} signature/module-surface file change(s) can break existing callers.`)
-    if (counts['body-changed']) reasons.push(`${counts['body-changed']} file(s) contain mapped executable body changes.`)
-    if (counts.added && !includeAddedSeeds) reasons.push(`${counts.added} purely additive file change(s) create no dependent seeds by default.`)
-    if (counts['metadata-only']) reasons.push(`${counts['metadata-only']} metadata-only file change(s) create no dependent seeds.`)
-    if (counts['test-only']) reasons.push(`${counts['test-only']} test-only file change(s) are labelled explicitly and create no product blast-radius seeds.`)
-    if (counts.unknown) reasons.push(`${counts.unknown} file change(s) remain unknown and are seeded conservatively.`)
-    if (!reasons.length) reasons.push('No changed files were present in the supplied diff.')
-    return reasons
-}
-
-export function classifyChangeImpact({
-    repoRoot = '', graph = {}, base = '', diffText, files = [], includeAddedSeeds = false,
-    limits: requestedLimits = {},
-} = {}) {
-    const limits = changeLimits(requestedLimits)
-    const explicitFiles = validExplicitFiles(files)
-    const input = collectDiffInput({diffText, repoRoot, base, explicitFiles, limits})
-    const fallbackFiles = validExplicitFiles([...explicitFiles, ...(input.fallbackFiles || [])]).slice(0, limits.maxFiles)
-    const indexed = indexChangeGraph(graph, limits)
-    const pathClassifier = createPathClassifier(repoRoot)
-    const parsed = input.available
-        ? parseZeroContextDiff(input.text, limits)
-        : {files: [], changedLines: 0, byteLength: 0, truncated: input.oversized, oversized: input.oversized, limits}
-    const analyzed = parsed.files.map((file) => classifyTestSurface(analyzeParsedFile(file, indexed, {includeAddedSeeds}), pathClassifier))
-    const represented = new Set(analyzed.flatMap((file) => [file.oldPath, file.newPath].filter(Boolean)))
-    for (const file of fallbackFiles) if (!represented.has(file)) analyzed.push(classifyTestSurface(
-        unknownChangedFile(file, indexed, input.available ? 'explicitly changed file had no textual hunk' : input.reason),
-        pathClassifier,
-    ))
-    if (!input.available && !fallbackFiles.length) analyzed.push(unknownChangedFile('(diff unavailable)', indexed, input.reason))
-    analyzed.sort((a, b) => a.path.localeCompare(b.path))
-
-    const incomplete = parsed.truncated || parsed.oversized || input.oversized || input.fallbackTruncated
-    const parsedEvidenceIncomplete = parsed.truncated || parsed.oversized || (input.oversized && !input.partialFallback)
-    if (parsedEvidenceIncomplete) for (const file of analyzed) {
-        if (file.classification === 'test-only') continue
-        file.classification = 'unknown'
-        file.reason = 'diff was truncated/oversized; symbol-level classification is incomplete'
-        const record = indexed.get(file.newPath) || indexed.get(file.oldPath)
-        file.seedIds = [...new Set([record?.fileNodeId, ...(record?.symbols || []).map((symbol) => symbol.id), ...file.seedIds].filter(Boolean))].sort()
-    }
-
-    const seeds = uniqueChangeSeeds(analyzed.flatMap((file) => file.seedIds), limits.maxSeeds)
-    let verdict = 'LOW'
-    for (const file of analyzed) {
-        const next = ['removed', 'signature-changed', 'unknown'].includes(file.classification)
-            ? 'HIGH' : file.classification === 'body-changed' ? 'MEDIUM' : 'LOW'
-        if (VERDICT_RANK[next] > VERDICT_RANK[verdict]) verdict = next
-    }
-    if (!input.available || input.oversized || parsed.truncated || seeds.truncated) verdict = 'HIGH'
-    const counts = Object.fromEntries(Object.keys(CHANGE_CLASS_RANK)
-        .map((name) => [name, analyzed.filter((file) => file.classification === name).length]))
-    return {
-        ok: input.available && !input.oversized && !parsed.truncated && !seeds.truncated,
-        source: input.source,
-        verdict,
-        reasons: classificationReasons(counts, {
-            available: input.available,
-            unavailableReason: input.reason,
-            truncated: incomplete,
-            includeAddedSeeds,
-        }),
-        seedIds: seeds.items,
-        files: analyzed,
-        summary: {
-            files: analyzed.length,
-            symbols: analyzed.reduce((sum, file) => sum + file.symbols.length, 0),
-            counts,
-            seeds: seeds.items.length,
-            totalSeedsBeforeCap: seeds.total,
-        },
-        bounds: {
-            ...limits, diffBytes: parsed.byteLength, changedLines: parsed.changedLines,
-            fallbackFiles: input.fallbackFiles?.length || 0,
-            truncated: input.oversized === true || !!parsed.truncated || seeds.truncated || input.fallbackTruncated === true,
-        },
-    }
-}

package/src/analysis/coverage-reports.js

@@ -1,235 +0,0 @@
-// graph-builder-coverage.js — coverage-report readers for the graph analysis. Parses Istanbul (summary/final),
-// lcov, Python coverage.json, and Go coverage.out into per-file line-hit maps, resolving report paths onto the
-// graph's known files. Split out of graph-builder-analysis.js (pure except for reading the repo's coverage files).
-import { existsSync, readFileSync } from "node:fs";
-import { join, relative, resolve } from "node:path";
-import { createRepoBoundary } from "../repo-path.js";
-
-export function normRepoPath(value) {
-  return String(value || "").replace(/\\/g, "/").replace(/^\.\//, "");
-}
-
-export function dirOfRepoPath(value) {
-  const p = normRepoPath(value);
-  const i = p.lastIndexOf("/");
-  return i >= 0 ? p.slice(0, i) : "";
-}
-
-export function normalizeRepoParts(value) {
-  const out = [];
-  for (const part of normRepoPath(value).split("/")) {
-    if (!part || part === ".") continue;
-    if (part === "..") out.pop();
-    else out.push(part);
-  }
-  return out.join("/");
-}
-
-function pct01(value) {
-  const n = Number(value);
-  if (!Number.isFinite(n)) return null;
-  return Math.max(0, Math.min(1, n > 1 ? n / 100 : n));
-}
-
-export function pctFromCounts(covered, total) {
-  const c = Number(covered);
-  const t = Number(total);
-  if (!Number.isFinite(c) || !Number.isFinite(t) || t <= 0) return null;
-  return Math.max(0, Math.min(1, c / t));
-}
-
-function resolveCoverageFile(rawPath, knownFiles, repoRoot) {
-  const known = (knownFiles || []).map(normalizeRepoParts).filter(Boolean);
-  const knownSet = new Set(known);
-  const candidates = [];
-  const add = (value) => {
-    const p = normalizeRepoParts(value);
-    if (p && !candidates.includes(p)) candidates.push(p);
-  };
-  const raw = String(rawPath || "").replace(/^file:\/\//i, "").replace(/[?#].*$/, "");
-  const normalizedRaw = normRepoPath(raw);
-  add(normalizedRaw);
-  add(normalizedRaw.replace(/^\.\//, ""));
-  if (repoRoot) {
-    try {
-      const rel = normRepoPath(relative(repoRoot, raw));
-      if (rel && !rel.startsWith("..")) add(rel);
-    } catch {
-      /* best effort */
-    }
-    const rootPrefix = `${normRepoPath(resolve(repoRoot)).toLowerCase()}/`;
-    const lowerRaw = normalizedRaw.toLowerCase();
-    if (lowerRaw.startsWith(rootPrefix)) add(normalizedRaw.slice(rootPrefix.length));
-  }
-  for (const candidate of candidates) if (knownSet.has(candidate)) return candidate;
-  const lower = normalizedRaw.toLowerCase();
-  const suffixHit = known
-    .slice()
-    .sort((a, b) => b.length - a.length)
-    .find((file) => lower.endsWith(`/${file.toLowerCase()}`) || lower === file.toLowerCase());
-  return suffixHit || candidates[0] || "";
-}
-
-function mergeCoverageEntry(map, rawPath, entry, knownFiles, repoRoot) {
-  const file = resolveCoverageFile(rawPath, knownFiles, repoRoot);
-  if (!file) return;
-  const current = map.get(file) || {};
-  map.set(file, {
-    pct: entry.pct != null ? entry.pct : current.pct ?? null,
-    total: entry.total != null ? entry.total : current.total ?? null,
-    covered: entry.covered != null ? entry.covered : current.covered ?? null,
-    lines: entry.lines || current.lines || null,
-    source: current.source && entry.source ? `${current.source}, ${entry.source}` : entry.source || current.source || ""
-  });
-}
-
-function addLineHit(lines, line, hit) {
-  const n = Math.max(1, Math.round(Number(line) || 0));
-  if (!n) return;
-  const current = lines.get(n);
-  lines.set(n, Math.max(Number(current) || 0, Number(hit) || 0));
-}
-
-function parseIstanbulSummary(map, filePath, knownFiles, repoRoot) {
-  const json = JSON.parse(readFileSync(filePath, "utf8"));
-  for (const [raw, value] of Object.entries(json || {})) {
-    if (raw === "total" || !value || typeof value !== "object") continue;
-    const lines = value.lines || value.statements || {};
-    mergeCoverageEntry(map, raw, {
-      pct: pct01(lines.pct),
-      total: Number.isFinite(Number(lines.total)) ? Number(lines.total) : null,
-      covered: Number.isFinite(Number(lines.covered)) ? Number(lines.covered) : null,
-      source: "coverage-summary.json"
-    }, knownFiles, repoRoot);
-  }
-}
-
-function parseIstanbulFinal(map, filePath, knownFiles, repoRoot) {
-  const json = JSON.parse(readFileSync(filePath, "utf8"));
-  for (const [raw, record] of Object.entries(json || {})) {
-    if (!record || typeof record !== "object") continue;
-    const statementMap = record.statementMap || {};
-    const hits = record.s || {};
-    const lines = new Map();
-    for (const [id, loc] of Object.entries(statementMap)) {
-      const hit = Number(hits[id]) || 0;
-      const start = Math.max(1, Math.round(Number(loc?.start?.line) || 0));
-      const end = Math.max(start, Math.round(Number(loc?.end?.line) || start));
-      for (let line = start; line <= end; line++) addLineHit(lines, line, hit);
-    }
-    const total = lines.size;
-    const covered = [...lines.values()].filter((hit) => Number(hit) > 0).length;
-    mergeCoverageEntry(map, record.path || raw, {
-      pct: pctFromCounts(covered, total),
-      total,
-      covered,
-      lines,
-      source: "coverage-final.json"
-    }, knownFiles, repoRoot);
-  }
-}
-
-function parseLcov(map, filePath, knownFiles, repoRoot) {
-  const flush = (record) => {
-    if (!record || !record.file) return;
-    const total = record.total ?? record.lines.size;
-    const covered = record.covered ?? [...record.lines.values()].filter((hit) => Number(hit) > 0).length;
-    mergeCoverageEntry(map, record.file, {
-      pct: pctFromCounts(covered, total),
-      total,
-      covered,
-      lines: record.lines,
-      source: "lcov.info"
-    }, knownFiles, repoRoot);
-  };
-  let current = null;
-  for (const rawLine of readFileSync(filePath, "utf8").split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (line.startsWith("SF:")) {
-      flush(current);
-      current = { file: line.slice(3), lines: new Map(), total: null, covered: null };
-    } else if (current && line.startsWith("DA:")) {
-      const [lineNo, count] = line.slice(3).split(",");
-      addLineHit(current.lines, lineNo, count);
-    } else if (current && line.startsWith("LF:")) {
-      current.total = Number(line.slice(3)) || current.total;
-    } else if (current && line.startsWith("LH:")) {
-      current.covered = Number(line.slice(3)) || current.covered;
-    } else if (line === "end_of_record") {
-      flush(current);
-      current = null;
-    }
-  }
-  flush(current);
-}
-
-function parseCoveragePyJson(map, filePath, knownFiles, repoRoot) {
-  const json = JSON.parse(readFileSync(filePath, "utf8"));
-  for (const [raw, file] of Object.entries(json?.files || {})) {
-    const lines = new Map();
-    for (const line of file.executed_lines || []) addLineHit(lines, line, 1);
-    for (const line of file.missing_lines || []) if (!lines.has(Number(line))) addLineHit(lines, line, 0);
-    const summary = file.summary || {};
-    const total = Number(summary.num_statements) || lines.size;
-    const covered = Number(summary.covered_lines) || [...lines.values()].filter((hit) => Number(hit) > 0).length;
-    mergeCoverageEntry(map, raw, {
-      pct: pct01(summary.percent_covered ?? summary.percent_covered_display) ?? pctFromCounts(covered, total),
-      total,
-      covered,
-      lines,
-      source: "coverage.json"
-    }, knownFiles, repoRoot);
-  }
-}
-
-function parseGoCoverage(map, filePath, knownFiles, repoRoot) {
-  const byFile = new Map();
-  for (const rawLine of readFileSync(filePath, "utf8").split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("mode:")) continue;
-    const m = line.match(/^(.+):(\d+)\.\d+,(\d+)\.\d+\s+\d+\s+(\d+)$/);
-    if (!m) continue;
-    const record = byFile.get(m[1]) || { lines: new Map() };
-    const start = Math.max(1, Number(m[2]) || 1);
-    const end = Math.max(start, Number(m[3]) || start);
-    for (let n = start; n <= end; n++) addLineHit(record.lines, n, Number(m[4]) || 0);
-    byFile.set(m[1], record);
-  }
-  for (const [raw, record] of byFile) {
-    const total = record.lines.size;
-    const covered = [...record.lines.values()].filter((hit) => Number(hit) > 0).length;
-    mergeCoverageEntry(map, raw, {
-      pct: pctFromCounts(covered, total),
-      total,
-      covered,
-      lines: record.lines,
-      source: "coverage.out"
-    }, knownFiles, repoRoot);
-  }
-}
-
-export function readCoverageForRepo(repoRoot, knownFiles) {
-  const out = new Map();
-  if (!repoRoot) return out;
-  const boundary = createRepoBoundary(repoRoot);
-  const candidates = [
-    ["coverage/coverage-summary.json", parseIstanbulSummary],
-    ["coverage/coverage-final.json", parseIstanbulFinal],
-    ["coverage/lcov.info", parseLcov],
-    ["lcov.info", parseLcov],
-    ["coverage/coverage.json", parseCoveragePyJson],
-    ["coverage.json", parseCoveragePyJson],
-    ["coverage.out", parseGoCoverage],
-    ["cover.out", parseGoCoverage]
-  ];
-  for (const [candidate, parser] of candidates) {
-    const resolved = boundary.resolve(candidate);
-    if (!resolved.ok || !existsSync(resolved.path)) continue;
-    try {
-      parser(out, resolved.path, knownFiles, repoRoot);
-    } catch {
-      /* malformed/foreign coverage report: ignore */
-    }
-  }
-  return out;
-}

package/src/analysis/cycle-route.js

@@ -1,14 +0,0 @@
-const MAX_REPRESENTATIVE_CYCLE_FILES = 64;
-
-// Keep the complete closed route for normal cycles. Very large SCCs still get a closed, deterministic
-// head/tail route without letting one finding consume the whole audit response.
-export function formatRepresentativeCycle(cycle, maxFiles = MAX_REPRESENTATIVE_CYCLE_FILES) {
-  const raw = Array.isArray(cycle) ? cycle.map(String).filter(Boolean) : [];
-  if (!raw.length) return "";
-  const closed = raw.length > 1 && raw[0] === raw[raw.length - 1] ? raw : [...raw, raw[0]];
-  const cap = Math.max(4, Number(maxFiles) || MAX_REPRESENTATIVE_CYCLE_FILES);
-  if (closed.length <= cap + 1) return closed.join(" → ");
-  const side = Math.max(2, Math.floor(cap / 2));
-  const omitted = closed.length - side * 2;
-  return `${closed.slice(0, side).join(" → ")} → … ${omitted} file(s) omitted … → ${closed.slice(-side).join(" → ")}`;
-}