weavatrix 0.3.14 → 1.1.0

package/src/analysis/change-classification/diff-parser.js

@@ -1,103 +0,0 @@
-import {changeLimits, normalizeChangePath} from './options.js'
-
-function decodeGitQuoted(value) {
-    const input = String(value || '').trim()
-    if (!input.startsWith('"')) return input.split('\t', 1)[0]
-    try { return JSON.parse(input) } catch { /* Git octal escapes are not JSON. */ }
-    const bytes = []
-    for (let index = 1; index < input.length - 1; index++) {
-        const char = input[index]
-        if (char !== '\\') { bytes.push(...Buffer.from(char)); continue }
-        const next = input[++index] || ''
-        if (/[0-7]/.test(next)) {
-            let octal = next
-            while (octal.length < 3 && /[0-7]/.test(input[index + 1] || '')) octal += input[++index]
-            bytes.push(parseInt(octal, 8))
-        } else {
-            const escapes = {n: 10, r: 13, t: 9, b: 8, f: 12, v: 11, '\\': 92, '"': 34}
-            bytes.push(escapes[next] ?? next.charCodeAt(0))
-        }
-    }
-    return Buffer.from(bytes).toString('utf8')
-}
-
-function diffPath(raw, prefix) {
-    const decoded = decodeGitQuoted(raw)
-    if (!decoded || decoded === '/dev/null') return null
-    return normalizeChangePath(decoded.startsWith(`${prefix}/`) ? decoded.slice(2) : decoded)
-}
-
-function headerPaths(line) {
-    const match = /^diff --git ("(?:\\.|[^"])*"|\S+) ("(?:\\.|[^"])*"|\S+)$/.exec(line)
-    return match
-        ? {oldPath: diffPath(match[1], 'a'), newPath: diffPath(match[2], 'b')}
-        : {oldPath: null, newPath: null}
-}
-
-const emptyFile = (paths = {}) => ({
-    oldPath: paths.oldPath || null,
-    newPath: paths.newPath || null,
-    newFile: false,
-    deletedFile: false,
-    renamed: false,
-    binary: false,
-    hunks: [],
-    additions: [],
-    removals: [],
-})
-
-export function parseZeroContextDiff(diffText, options = {}) {
-    const limits = changeLimits(options)
-    const original = String(diffText ?? '')
-    const byteLength = Buffer.byteLength(original)
-    const oversized = byteLength > limits.maxDiffBytes
-    const text = oversized ? original.slice(0, limits.maxDiffBytes) : original
-    const files = []
-    let file = null, hunk = null, changedLines = 0, truncated = oversized
-    const finish = () => {
-        if (!file) return
-        if ((file.oldPath || file.newPath) && files.length < limits.maxFiles) files.push(file)
-        else if (files.length >= limits.maxFiles) truncated = true
-        file = null; hunk = null
-    }
-    const addChange = (kind, line, oldLine, newLine, mappedNewLine) => {
-        changedLines++
-        if (changedLines > limits.maxChangedLines) { truncated = true; return }
-        const change = {
-            kind,
-            text: String(line).slice(0, limits.maxLineLength),
-            ...(oldLine != null ? {oldLine} : {}),
-            ...(newLine != null ? {newLine} : {}),
-            mappedNewLine,
-        }
-        ;(kind === 'added' ? file.additions : file.removals).push(change)
-    }
-    for (const line of text.split(/\r?\n/)) {
-        if (line.startsWith('diff --git ')) { finish(); file = emptyFile(headerPaths(line)); continue }
-        if (!file && line.startsWith('--- ')) file = emptyFile()
-        if (!file) continue
-        if (line.startsWith('new file mode ')) { file.newFile = true; continue }
-        if (line.startsWith('deleted file mode ')) { file.deletedFile = true; continue }
-        if (line.startsWith('rename from ')) { file.oldPath = normalizeChangePath(decodeGitQuoted(line.slice(12))); file.renamed = true; continue }
-        if (line.startsWith('rename to ')) { file.newPath = normalizeChangePath(decodeGitQuoted(line.slice(10))); file.renamed = true; continue }
-        if (line.startsWith('Binary files ') || line === 'GIT binary patch') { file.binary = true; continue }
-        if (!hunk && line.startsWith('--- ')) { file.oldPath = diffPath(line.slice(4), 'a'); if (!file.oldPath) file.newFile = true; continue }
-        if (!hunk && line.startsWith('+++ ')) { file.newPath = diffPath(line.slice(4), 'b'); if (!file.newPath) file.deletedFile = true; continue }
-        const match = /^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/.exec(line)
-        if (match) {
-            hunk = {
-                oldStart: Number(match[1]), oldCount: match[2] == null ? 1 : Number(match[2]),
-                newStart: Number(match[3]), newCount: match[4] == null ? 1 : Number(match[4]),
-                oldCursor: Number(match[1]), newCursor: Number(match[3]),
-            }
-            file.hunks.push({oldStart: hunk.oldStart, oldCount: hunk.oldCount, newStart: hunk.newStart, newCount: hunk.newCount})
-            continue
-        }
-        if (!hunk || line.startsWith('\\ No newline')) continue
-        if (line.startsWith('+')) { addChange('added', line.slice(1), null, hunk.newCursor, hunk.newCursor); hunk.newCursor++ }
-        else if (line.startsWith('-')) { addChange('removed', line.slice(1), hunk.oldCursor, null, hunk.newCursor); hunk.oldCursor++ }
-        else { hunk.oldCursor++; hunk.newCursor++ }
-    }
-    finish()
-    return {files, byteLength, changedLines: Math.min(changedLines, limits.maxChangedLines), truncated, oversized, limits}
-}

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-tarpaulin.js

@@ -1,112 +0,0 @@
-import { readFileSync } from "node:fs";
-
-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));
-}
-
-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 addLineHit(lines, line, hit) {
-  const value = Number(line);
-  if (!Number.isFinite(value) || value <= 0) return;
-  const n = Math.round(value);
-  if (n < 1) return;
-  const current = lines.get(n);
-  lines.set(n, Math.max(Number(current) || 0, Number(hit) || 0));
-}
-
-function numericLineList(value) {
-  const input = Array.isArray(value) ? value : [];
-  return input
-    .map((line) => Number(line))
-    .filter((line) => Number.isFinite(line) && line > 0)
-    .map((line) => Math.round(line));
-}
-
-function legacyLineGroups(record) {
-  if (!record || typeof record !== "object") return { covered: [], uncovered: [] };
-  const lines = record.lines && typeof record.lines === "object" ? record.lines : {};
-  return {
-    covered: [
-      ...numericLineList(record.covered),
-      ...numericLineList(record.covered_lines),
-      ...numericLineList(record.coveredLines),
-      ...numericLineList(lines.covered),
-      ...numericLineList(lines.covered_lines),
-    ],
-    uncovered: [
-      ...numericLineList(record.uncovered),
-      ...numericLineList(record.uncovered_lines),
-      ...numericLineList(record.uncoveredLines),
-      ...numericLineList(record.missing),
-      ...numericLineList(record.missing_lines),
-      ...numericLineList(lines.uncovered),
-      ...numericLineList(lines.uncovered_lines),
-      ...numericLineList(lines.missing),
-    ],
-  };
-}
-
-function recordPath(record) {
-  const raw = record?.path || record?.file || record?.filename || record?.name;
-  if (Array.isArray(raw)) return raw.map(String).filter(Boolean).join("/");
-  return raw;
-}
-
-function reportEntries(json) {
-  const files = json?.files || json?.coverage || json;
-  if (Array.isArray(files)) {
-    return files.map((record) => [recordPath(record), record]).filter(([raw]) => raw);
-  }
-  if (files && typeof files === "object") return Object.entries(files);
-  return [];
-}
-
-function coveragePct(record, covered, total) {
-  const summary = record?.summary && typeof record.summary === "object" ? record.summary : {};
-  return pct01(
-    record?.coverage
-    ?? record?.coverage_percentage
-    ?? record?.line_coverage
-    ?? summary.coverage
-    ?? summary.coverage_percentage
-    ?? summary.percent
-  )
-    ?? pctFromCounts(record?.covered, record?.coverable)
-    ?? pctFromCounts(covered, total);
-}
-
-export function readTarpaulinCoverage(filePath) {
-  const json = JSON.parse(readFileSync(filePath, "utf8"));
-  return reportEntries(json).map(([path, record]) => {
-    const lines = new Map();
-    for (const trace of Array.isArray(record?.traces) ? record.traces : []) {
-      if (!trace?.stats || typeof trace.stats !== "object" || !("Line" in trace.stats)) continue;
-      addLineHit(lines, trace.line, trace.stats.Line);
-    }
-    const legacy = legacyLineGroups(record);
-    for (const line of legacy.uncovered) addLineHit(lines, line, 0);
-    for (const line of legacy.covered) addLineHit(lines, line, 1);
-    const measuredTotal = lines.size;
-    const measuredCovered = [...lines.values()].filter((hit) => Number(hit) > 0).length;
-    const reportedTotal = Number(record?.coverable);
-    const reportedCovered = Number(record?.covered);
-    return {
-      path,
-      entry: {
-        pct: coveragePct(record, measuredCovered, measuredTotal),
-        total: Number.isFinite(reportedTotal) ? reportedTotal : measuredTotal,
-        covered: Number.isFinite(reportedCovered) ? reportedCovered : measuredCovered,
-        lines,
-        source: "tarpaulin-report.json",
-      },
-    };
-  });
-}