weavatrix 0.3.14 → 1.1.0

package/src/analysis/structure/findings.js

@@ -1,162 +0,0 @@
-import {makeFinding} from '../findings.js'
-import {formatRepresentativeCycle} from '../cycle-route.js'
-import {
-    buildFileImportGraph,
-    checkBoundaries,
-    findOrphans,
-    findSccs,
-    representativeCycle,
-} from './dependency-graph.js'
-
-const MAX_CYCLE_FINDINGS = 50
-const MAX_BOUNDARY_FINDINGS = 100
-
-const edgeCountIn = (component, edges) => {
-    const inside = new Set(component)
-    return edges.reduce((count, [source, target]) => count + (inside.has(source) && inside.has(target) ? 1 : 0), 0)
-}
-
-function runtimeCycleFinding(adjacency, component) {
-    const cycle = representativeCycle(adjacency, component)
-    const cycleRoute = formatRepresentativeCycle(cycle)
-    return makeFinding({
-        category: 'structure',
-        rule: 'circular-dep',
-        severity: component.length > 4 ? 'high' : 'medium',
-        confidence: 'high',
-        title: `Circular dependency: ${component.length} files`,
-        detail: `${cycleRoute}${component.length + 1 > cycle.length ? ` (representative loop; the tangle spans ${component.length} files)` : ''}. Break the cycle by extracting the shared piece or inverting one import.`,
-        cycleRoute,
-        cycleMembers: [...component].sort(),
-        file: cycle[0],
-        graphNodeId: cycle[0],
-        evidence: cycle.map((file) => ({file, line: 0, snippet: ''})),
-        source: 'internal',
-        fixHint: 'extract the shared code into a module both sides import, or invert the weaker dependency',
-    })
-}
-
-function compileTimeFinding(adjacency, component, runtimeComponents, edges) {
-    const cycle = representativeCycle(adjacency, component)
-    const cycleRoute = formatRepresentativeCycle(cycle)
-    const runtimeInside = edgeCountIn(component, edges.runtime)
-    const typeInside = edgeCountIn(component, edges.typeOnly)
-    const compileInside = edgeCountIn(component, edges.compileOnly)
-    const containsRuntimeCycle = runtimeComponents.some((runtime) => runtime.every((file) => component.includes(file)))
-    const typeSpecific = compileInside === 0
-    return makeFinding({
-        category: 'structure',
-        rule: typeSpecific ? 'type-coupling' : 'compile-time-coupling',
-        severity: 'info',
-        confidence: 'high',
-        title: `${containsRuntimeCycle
-            ? (typeSpecific ? 'Type imports expand dependency coupling' : 'Compile-time edges expand dependency coupling')
-            : (typeSpecific ? 'Type-induced dependency cycle (no runtime cycle)' : 'Compile-time dependency cycle (no runtime cycle)')}: ${component.length} files`,
-        detail: `${cycleRoute}. This strongly-connected group needs compile-time-only edges to close; it contains ${runtimeInside} runtime edge(s), ${typeInside} type-only edge(s), and ${compileInside} compile-only edge(s)${containsRuntimeCycle ? ', with a smaller runtime cycle reported separately' : ', while its runtime import graph is acyclic'}. Treat this as design coupling, not an initialization-order failure.`,
-        cycleRoute,
-        cycleMembers: [...component].sort(),
-        file: cycle[0],
-        graphNodeId: cycle[0],
-        evidence: cycle.map((file) => ({file, line: 0, snippet: ''})),
-        source: 'internal',
-        fixHint: 'review the compile-time ownership only if the coupling impedes changes; no runtime-cycle fix is required',
-    })
-}
-
-// Idiomatic Rust module trees close compile-time SCCs by construction: the parent (mod.rs, lib.rs,
-// main.rs, or a 2018-edition foo.rs) declares `mod child` while children reach back via super::/crate::.
-// Suppress only when every member is a .rs file sitting under one anchor's directory; genuine
-// cross-directory .rs cycles keep their findings.
-export function isRustModuleTreeComponent(component) {
-    if (!component.every((file) => String(file).endsWith('.rs'))) return false
-    return component.some((anchor) => {
-        const path = String(anchor)
-        const slash = path.lastIndexOf('/')
-        const base = path.slice(slash + 1)
-        const anchorDir = ['mod.rs', 'lib.rs', 'main.rs'].includes(base)
-            ? (slash >= 0 ? path.slice(0, slash) : '')
-            : path.slice(0, -'.rs'.length)
-        return anchorDir !== '' && component.every((member) => member === anchor || String(member).startsWith(`${anchorDir}/`))
-    })
-}
-
-export function computeStructureFindings(graph, {rules = {}, entrySet = new Set(), externalImportFiles = new Set()} = {}) {
-    const imports = buildFileImportGraph(graph)
-    const findings = []
-    const runtimeComponents = findSccs(imports.adj).sort((a, b) => b.length - a.length)
-    for (const component of runtimeComponents.slice(0, MAX_CYCLE_FINDINGS)) {
-        findings.push(runtimeCycleFinding(imports.adj, component))
-    }
-
-    const runtimeKeys = new Set(runtimeComponents.map((component) => [...component].sort().join('\0')))
-    const allComponents = findSccs(imports.allAdj).sort((a, b) => b.length - a.length)
-    const compileTimeCandidates = allComponents.filter((component) => !runtimeKeys.has([...component].sort().join('\0')))
-    const rustModuleTreeComponents = compileTimeCandidates.filter((component) => isRustModuleTreeComponent(component))
-    const compileTimeCouplings = compileTimeCandidates.filter((component) => !isRustModuleTreeComponent(component))
-    for (const component of compileTimeCouplings.slice(0, MAX_CYCLE_FINDINGS)) {
-        findings.push(compileTimeFinding(imports.allAdj, component, runtimeComponents, {
-            runtime: imports.edges,
-            typeOnly: imports.typeOnlyEdges,
-            compileOnly: imports.compileOnlyEdges,
-        }))
-    }
-    if (runtimeComponents.length > MAX_CYCLE_FINDINGS) findings.push(makeFinding({
-        category: 'structure', rule: 'circular-dep', severity: 'info', confidence: 'high',
-        title: `…and ${runtimeComponents.length - MAX_CYCLE_FINDINGS} more dependency cycles`,
-        detail: `Cycle findings are capped at ${MAX_CYCLE_FINDINGS}; ${runtimeComponents.length} strongly-connected groups exist in total.`,
-        source: 'internal',
-    }))
-
-    for (const orphan of findOrphans(graph, {entrySet, externalImportFiles})) findings.push(makeFinding({
-        category: 'structure',
-        rule: 'orphan-file',
-        severity: 'info',
-        confidence: orphan.importsExternals ? 'low' : 'medium',
-        title: `Orphan file: ${orphan.file}`,
-        detail: `No repo file imports it and it imports/calls nothing in the repo${orphan.importsExternals ? ' (it does use npm packages — possibly a standalone script or tool)' : ''}. Possibly dead, possibly an undeclared entry point.`,
-        file: orphan.file,
-        graphNodeId: orphan.file,
-        source: 'internal',
-    }))
-
-    const violations = checkBoundaries(imports.edges, rules)
-    for (const item of violations.slice(0, MAX_BOUNDARY_FINDINGS)) findings.push(makeFinding({
-        category: 'structure',
-        rule: 'boundary-violation',
-        severity: ['critical', 'high', 'medium', 'low', 'info'].includes(item.severity) ? item.severity : 'medium',
-        confidence: 'high',
-        title: `Boundary violation (${item.name}): ${item.from} → ${item.to}`,
-        detail: `${item.kind === 'allowedOnly' ? 'Import leaves the allowed set' : 'Forbidden import'}${item.comment ? `: ${item.comment}` : ''}.`,
-        file: item.from,
-        graphNodeId: item.from,
-        evidence: [{file: item.from, line: 0, snippet: `imports ${item.to}`}],
-        source: 'internal',
-    }))
-    if (violations.length > MAX_BOUNDARY_FINDINGS) findings.push(makeFinding({
-        category: 'structure', rule: 'boundary-violation', severity: 'info', confidence: 'high',
-        title: `…and ${violations.length - MAX_BOUNDARY_FINDINGS} more boundary violations`,
-        detail: `Boundary findings are capped at ${MAX_BOUNDARY_FINDINGS}; ${violations.length} edges violate the rules in total.`,
-        source: 'internal',
-    }))
-
-    return {
-        findings,
-        stats: {
-            importEdges: imports.allEdges.length,
-            runtimeImportEdges: imports.edges.length,
-            typeOnlyImportEdges: imports.typeOnlyEdges.length,
-            compileOnlyImportEdges: imports.compileOnlyEdges.length,
-            compileTimeImportEdges: imports.compileTimeEdges.length,
-            cycles: runtimeComponents.length,
-            runtimeCycles: runtimeComponents.length,
-            largestCycle: runtimeComponents[0]?.length || 0,
-            typeCouplings: compileTimeCouplings.length,
-            largestTypeCoupling: compileTimeCouplings[0]?.length || 0,
-            compileTimeCouplings: compileTimeCouplings.length,
-            largestCompileTimeCoupling: compileTimeCouplings[0]?.length || 0,
-            rustModuleTreeCouplings: rustModuleTreeComponents.length,
-            orphans: findings.filter((finding) => finding.rule === 'orphan-file').length,
-            boundaryViolations: violations.length,
-        },
-    }
-}

package/src/analysis/task-retrieval.js

@@ -1,107 +0,0 @@
-import {PATH_CLASS_NAMES, PATH_CLASS_TASK_QUERY_TERMS, createPathClassifier, hasPathClass} from '../path-classification.js'
-
-const words = (value) => new Set(String(value || '').toLowerCase().match(/[\p{L}_$][\p{L}\p{N}_$-]{2,}/gu) || [])
-const fileOf = (node) => String(node?.source_file || (String(node?.id || '').includes('#') ? String(node.id).split('#')[0] : node?.id || '')).replace(/\\/g, '/')
-const isSymbol = (id) => String(id || '').includes('#')
-
-const INTENT_TRANSLATIONS = [
-  [/авториз|аутентиф|логин|сесси|токен/iu, 'auth authentication login session token'],
-  [/маршрут|роут|эндпоинт|апи|http/iu, 'route router endpoint api http'],
-  [/тест|покрыти/iu, 'test spec coverage verify'],
-  [/к[эе]ш|хранилищ/iu, 'cache store storage'],
-  [/баз[аы]|запрос|sql/iu, 'database query sql'],
-  [/конфиг|настройк/iu, 'config settings configuration'],
-  [/безопас|вредонос|секрет/iu, 'security malware secret'],
-  [/зависим|импорт/iu, 'dependency import module'],
-  [/дублик|клон/iu, 'duplicate clone'],
-]
-
-export function expandTaskQuery(task) {
-  const text = String(task || '')
-  const expansions = INTENT_TRANSLATIONS.filter(([pattern]) => pattern.test(text)).map(([, value]) => value)
-  return [...new Set([text, ...expansions])].join(' ')
-}
-
-function overlapScore(taskWords, node) {
-  const haystack = words(`${node?.label || ''} ${node?.id || ''} ${node?.symbol_kind || ''}`)
-  let score = 0
-  for (const word of taskWords) if (haystack.has(word)) score += 8
-  return score
-}
-
-function addCandidate(map, node, score, reason) {
-  if (!node?.id) return
-  const id = String(node.id)
-  const current = map.get(id) || {node, score: 0, reasons: new Set()}
-  current.score += score
-  current.reasons.add(reason)
-  map.set(id, current)
-}
-
-function containedSymbols(g, node) {
-  if (isSymbol(node?.id)) return [node]
-  return (g.out.get(String(node?.id)) || [])
-    .filter((edge) => edge.relation === 'contains')
-    .map((edge) => g.byId.get(String(edge.id)))
-    .filter(Boolean)
-}
-
-// Combines intent-expanded search seeds with exact changed symbols. The result deliberately stays
-// deterministic and source-free; exact LSP/source evidence is collected by context_bundle later.
-export function retrieveTaskContext(g, {
-  task, semanticSeeds = [], changedSeedIds = [], maxSymbols = 3, repoRoot = null, includeClassified = false,
-} = {}) {
-  const expandedTask = expandTaskQuery(task)
-  const taskWords = words(expandedTask)
-  const requestedClasses = new Set(Object.entries(PATH_CLASS_TASK_QUERY_TERMS)
-    .filter(([, terms]) => terms.some((term) => taskWords.has(term)))
-    .map(([name]) => name))
-  if (requestedClasses.has('test')) requestedClasses.add('e2e')
-  if (requestedClasses.has('e2e')) requestedClasses.add('test')
-  const classifier = createPathClassifier(repoRoot)
-  const classificationCache = new Map()
-  const changedFiles = new Set((changedSeedIds || []).map((id) => fileOf(g.byId.get(String(id)) || {id})))
-  const pathAllowed = (node) => {
-    const file = fileOf(node)
-    if (!file || changedFiles.has(file) || includeClassified === true) return true
-    // Node-level test surfaces (Rust #[cfg(test)]) follow the same production-first policy.
-    if (node?.test_surface === true && !requestedClasses.has('test')) return false
-    if (!classificationCache.has(file)) classificationCache.set(file, classifier.explain(file, {content: ''}))
-    const info = classificationCache.get(file)
-    const classes = PATH_CLASS_NAMES.filter((name) => hasPathClass(info, name))
-    if (!info?.excluded && !classes.length) return true
-    return classes.some((name) => requestedClasses.has(name))
-  }
-  const candidates = new Map()
-  for (const id of changedSeedIds || []) {
-    const node = g.byId.get(String(id))
-    if (node) addCandidate(candidates, node, 100 + overlapScore(taskWords, node), 'changed-symbol')
-  }
-  for (const seed of semanticSeeds || []) addCandidate(candidates, seed, 45 + overlapScore(taskWords, seed), 'task-intent')
-
-  for (const candidate of [...candidates.values()]) {
-    for (const symbol of containedSymbols(g, candidate.node)) {
-      const degree = (g.out.get(String(symbol.id)) || []).length + (g.inn.get(String(symbol.id)) || []).length
-      addCandidate(candidates, symbol, 22 + overlapScore(taskWords, symbol) + Math.min(12, degree), `symbol-in:${fileOf(candidate.node)}`)
-    }
-  }
-
-  const symbolCandidates = [...candidates.values()].filter((item) => isSymbol(item.node.id))
-  const ranked = symbolCandidates
-    .filter((item) => pathAllowed(item.node))
-    .sort((left, right) => right.score - left.score || String(left.node.id).localeCompare(String(right.node.id)))
-  const limit = Math.max(1, Math.min(5, Number(maxSymbols) || 3))
-  return {
-    method: 'intent-expanded graph retrieval + exact changed-symbol seeds',
-    status: ranked.length ? 'COMPLETE' : 'NO_SYMBOLS',
-    selected: ranked.slice(0, limit).map((item) => ({
-      id: String(item.node.id), label: item.node.label || String(item.node.id), file: fileOf(item.node),
-      kind: item.node.symbol_kind || null, score: item.score, reasons: [...item.reasons].sort(),
-    })),
-    candidateCount: ranked.length,
-    suppressedClassified: symbolCandidates.length - ranked.length,
-    pathPolicy: includeClassified === true
-      ? {mode: 'ALL_CLASSIFIED'}
-      : {mode: 'PRODUCTION_FIRST', requestedClasses: [...requestedClasses].sort(), changedFilesPinned: changedFiles.size},
-  }
-}

package/src/analysis/transport-contracts.js

@@ -1,224 +0,0 @@
-import { createRepoBoundary } from "../repo-path.js";
-import { lineNumberAt, uniqueBy } from "../util.js";
-import { listRepoFiles, readRepoText } from "./internal-audit/repo-files.js";
-import { affectedForEndpoint, reverseRuntimeImports } from "./http-contracts/graph-context.js";
-import { loadTransportRuntimeEvidence } from "./transport-runtime-evidence.js";
-
-const TEST_RE = /(^|\/)(?:test|tests|__tests__|spec|e2e|fixtures?)(\/|$)|[._-](?:test|spec)\.[a-z0-9]+$/i;
-const SOURCE_RE = /\.(?:[cm]?[jt]sx?|py|go|java|rs|cs|proto|graphql|gql)$/i;
-const lineAt = lineNumberAt;
-const norm = (value) => String(value || "").toLowerCase().replace(/[^a-z0-9]+/g, "");
-
-function sourcesFor(descriptor, { includeTests, maxFiles }) {
-  const boundary = createRepoBoundary(descriptor.repoRoot);
-  if (!boundary.root) return { sources: [], reasons: [`${descriptor.id}: repository boundary is unreadable`] };
-  const candidates = listRepoFiles(boundary.root).filter((file) => SOURCE_RE.test(file) && (includeTests || !TEST_RE.test(file))).sort();
-  const sources = [];
-  for (const file of candidates.slice(0, maxFiles)) {
-    const text = readRepoText(boundary, file);
-    if (text != null) sources.push({ file, text });
-  }
-  return { sources, reasons: candidates.length > maxFiles ? [`${descriptor.id}: transport file cap reached`] : [] };
-}
-
-function graphQlEvidence(source, role) {
-  const contracts = [], uncertain = [];
-  for (const schema of source.text.matchAll(/\btype\s+(Query|Mutation|Subscription)\s*(?:extends\s+\w+\s*)?\{([\s\S]*?)\}/gi)) {
-    for (const field of schema[2].matchAll(/^\s*([A-Za-z_]\w*)\s*(?:\([^)]*\))?\s*:/gm)) contracts.push({
-      transport: "graphql", side: "server", operation: schema[1].toUpperCase(), name: field[1], file: source.file,
-      line: lineAt(source.text, schema.index + schema[0].indexOf(field[0])), detector: "graphql-schema",
-    });
-  }
-  for (const operation of source.text.matchAll(/\b(query|mutation|subscription)\s*(?:[A-Za-z_]\w*\s*)?(?:\([^)]*\)\s*)?\{\s*([A-Za-z_]\w*)/gi)) contracts.push({
-    transport: "graphql", side: role === "backend" ? "server-call" : "client", operation: operation[1].toUpperCase(), name: operation[2],
-    file: source.file, line: lineAt(source.text, operation.index), detector: "graphql-operation",
-  });
-  for (const dynamic of source.text.matchAll(/\b(?:gql|graphql)\s*(?:\(|`)\s*\$\{|\b(?:query|mutate)\s*\(\s*(?!["'`])/gi)) uncertain.push({
-    transport: "graphql", file: source.file, line: lineAt(source.text, dynamic.index), reason: "GraphQL document or operation is runtime-computed",
-  });
-  return { contracts, uncertain };
-}
-
-function grpcEvidence(source, role) {
-  const contracts = [], uncertain = [], aliases = new Map();
-  for (const service of source.text.matchAll(/\bservice\s+([A-Za-z_]\w*)\s*\{([\s\S]*?)\}/g)) {
-    for (const rpc of service[2].matchAll(/\brpc\s+([A-Za-z_]\w*)\s*\(/g)) contracts.push({
-      transport: "grpc", side: "server", service: service[1], name: rpc[1], file: source.file,
-      line: lineAt(source.text, service.index + service[0].indexOf(rpc[0])), detector: "proto-service",
-    });
-  }
-  const aliasPatterns = [
-    /\b(?:const|let|var)\s+([A-Za-z_$][\w$]*)\s*=\s*new\s+([A-Za-z_]\w*(?:Service)?Client)\b/g,
-    /\b([A-Za-z_]\w*)\s*=\s*([A-Za-z_]\w*Stub)\s*\(/g,
-    /\b([A-Za-z_]\w*)\s*:?=\s*\w*\.New([A-Za-z_]\w*)Client\s*\(/g,
-    /\b(?:[A-Za-z_]\w*\.)*([A-Za-z_]\w*(?:Blocking|Future|Async)?Stub)\s+([A-Za-z_]\w*)\s*[=;]/g,
-  ];
-  for (const [index, pattern] of aliasPatterns.entries()) for (const match of source.text.matchAll(pattern)) {
-    const alias = index === 3 ? match[2] : match[1];
-    const type = index === 3 ? match[1] : match[2];
-    aliases.set(alias, type.replace(/(?:Service)?Client$|(?:Blocking|Future|Async)?Stub$/i, ""));
-  }
-  for (const call of source.text.matchAll(/\b([A-Za-z_$][\w$]*)\s*(?:\.|->)\s*([A-Za-z_]\w*)\s*\(/g)) {
-    if (!aliases.has(call[1])) continue;
-    contracts.push({ transport: "grpc", side: role === "backend" ? "server-call" : "client", service: aliases.get(call[1]), name: call[2], file: source.file, line: lineAt(source.text, call.index), detector: "grpc-stub-call" });
-  }
-  for (const dynamic of source.text.matchAll(/\b(?:ServerReflection|ProtoReflection|grpc\.reflection|Class\.forName|Method\.invoke|reflect\.Value|dynamicStub)\b/g)) uncertain.push({
-    transport: "grpc", file: source.file, line: lineAt(source.text, dynamic.index), reason: "gRPC/reflection target is runtime-resolved",
-  });
-  return { contracts, uncertain };
-}
-
-function eventEvidence(source, role) {
-  const contracts = [], uncertain = [];
-  const add = (side, kind, match, topicIndex = 2) => contracts.push({
-    transport: "event", side, kind, name: match[topicIndex], file: source.file, line: lineAt(source.text, match.index), detector: "static-topic",
-  });
-  const subscriptions = [
-    /\b(?:consumer|kafka|bus|events?|eventBus)\s*(?:\.|->)\s*(subscribe|on|consume)\s*\(\s*["'`]([^"'`]+)["'`]/gi,
-    /@KafkaListener\s*\([^)]*\btopics?\s*=\s*["']([^"']+)["']/gi,
-    /\bsubscribe\s*\(\s*\{\s*topic\s*:\s*["'`]([^"'`]+)["'`]/gi,
-  ];
-  for (const [index, pattern] of subscriptions.entries()) for (const match of source.text.matchAll(pattern)) add("subscriber", index === 0 ? match[1] : "subscribe", match, index === 0 ? 2 : 1);
-  const publications = [
-    /\b(?:producer|kafka|bus|events?|eventBus|kafkaTemplate)\s*(?:\.|->)\s*(publish|emit|send|produce)\s*\(\s*["'`]([^"'`]+)["'`]/gi,
-    /\b(?:producer|kafka)\s*(?:\.|->)\s*send\s*\(\s*\{\s*topic\s*:\s*["'`]([^"'`]+)["'`]/gi,
-  ];
-  for (const [index, pattern] of publications.entries()) for (const match of source.text.matchAll(pattern)) add("publisher", index === 0 ? match[1] : "send", match, index === 0 ? 2 : 1);
-  for (const dynamic of source.text.matchAll(/\b(?:subscribe|publish|emit|consume|produce)\s*\(\s*(?!["'`{])([A-Za-z_$][\w$]*)/gi)) uncertain.push({
-    transport: "event", file: source.file, line: lineAt(source.text, dynamic.index), reason: `Event topic is runtime-computed (${dynamic[1]})`, role,
-  });
-  return { contracts, uncertain };
-}
-
-const contractIdentity = (item) => `${item.transport}|${item.side}|${norm(item.service)}|${item.operation || ""}|${item.name}`;
-
-function mergeRuntimeContracts(staticContracts, observations) {
-  const contracts = staticContracts.map((item) => ({ ...item, evidence: ["STATIC"] }));
-  const byIdentity = new Map(contracts.map((item) => [contractIdentity(item), item]));
-  for (const observation of observations) {
-    const key = contractIdentity(observation);
-    const existing = byIdentity.get(key);
-    if (existing) {
-      existing.runtimeObserved = true;
-      existing.observedCount = (existing.observedCount || 0) + observation.observedCount;
-      existing.evidence = ["STATIC", "RUNTIME"];
-      continue;
-    }
-    const added = { ...observation, evidence: ["RUNTIME"] };
-    contracts.push(added); byIdentity.set(key, added);
-  }
-  return contracts;
-}
-
-function sameRuntimeLocation(uncertain, observation) {
-  return observation.file && observation.line && observation.transport === uncertain.transport &&
-    observation.file === uncertain.file && observation.line === uncertain.line;
-}
-
-function detect(descriptor, role, options) {
-  const loaded = sourcesFor(descriptor, options), contracts = [], uncertain = [];
-  for (const source of loaded.sources) {
-    for (const detector of [graphQlEvidence, grpcEvidence, eventEvidence]) {
-      const result = detector(source, role);
-      contracts.push(...result.contracts); uncertain.push(...result.uncertain);
-    }
-  }
-  const runtime = loadTransportRuntimeEvidence(descriptor, {
-    file: options.runtimeEvidenceFiles?.[descriptor.id],
-    maxAgeHours: options.runtimeEvidenceMaxAgeHours,
-    transport: options.transport,
-    now: options.now,
-  });
-  const runtimeContracts = runtime.observations.filter((item) => options.transport === "all" || item.transport === options.transport);
-  const resolvedRuntime = uncertain.filter((item) => runtimeContracts.some((observation) => sameRuntimeLocation(item, observation)));
-  const unresolved = uncertain.filter((item) => !runtimeContracts.some((observation) => sameRuntimeLocation(item, observation)));
-  return {
-    contracts: mergeRuntimeContracts(
-      uniqueBy(contracts, (item) => `${item.transport}|${item.side}|${item.service || ""}|${item.operation || ""}|${item.name}|${item.file}|${item.line}`),
-      runtimeContracts,
-    ),
-    uncertain: uniqueBy(unresolved, (item) => `${item.transport}|${item.file}|${item.line}|${item.reason}`),
-    resolvedRuntime: uniqueBy(resolvedRuntime, (item) => `${item.transport}|${item.file}|${item.line}|${item.reason}`),
-    reasons: [...loaded.reasons, ...runtime.reasons],
-    runtime,
-    filesScanned: loaded.sources.length,
-  };
-}
-
-function contractMatch(server, caller, backendServers) {
-  if (server.transport !== caller.transport) return null;
-  const runtime = server.runtimeObserved || caller.runtimeObserved;
-  const match = (kind) => ({ confidence: "high", kind, evidence: runtime ? "RUNTIME_OBSERVED" : "STATIC" });
-  if (server.transport === "graphql" && caller.side === "client" && server.operation === caller.operation && server.name === caller.name) return match("operation-field");
-  if (server.transport === "grpc" && caller.side === "client" && norm(server.name) === norm(caller.name)) {
-    if (caller.service && norm(server.service) === norm(caller.service)) return match("service-method");
-    const sameMethod = backendServers.filter((item) => item.transport === "grpc" && norm(item.name) === norm(caller.name));
-    if (!caller.service && sameMethod.length === 1) return { confidence: "medium", kind: "unique-method", evidence: runtime ? "RUNTIME_OBSERVED" : "STATIC" };
-  }
-  if (server.transport === "event" && server.name === caller.name && server.side !== caller.side) return match("topic-direction");
-  return null;
-}
-
-export function analyzeTransportContracts(input = {}) {
-  const transport = ["all", "graphql", "grpc", "event"].includes(input.transport) ? input.transport : "all";
-  const options = {
-    includeTests: input.includeTests === true,
-    maxFiles: Math.max(1, Math.min(10_000, Number(input.maxFiles) || 3_000)),
-    transport,
-    runtimeEvidenceFiles: input.runtimeEvidenceFiles || {},
-    runtimeEvidenceMaxAgeHours: input.runtimeEvidenceMaxAgeHours,
-    now: input.now,
-  };
-  const backend = detect(input.backend, "backend", options);
-  const clients = (input.clients || []).map((descriptor) => ({ descriptor, evidence: detect(descriptor, "client", options), reverse: reverseRuntimeImports(descriptor.graph) }));
-  const selected = (item) => transport === "all" || item.transport === transport;
-  const backendContracts = backend.contracts.filter(selected);
-  const servers = backendContracts.filter((item) => item.side === "server" || item.transport === "event");
-  const results = [];
-  for (const server of servers) {
-    const callsites = [];
-    for (const client of clients) for (const caller of client.evidence.contracts.filter(selected)) {
-      const match = contractMatch(server, caller, servers);
-      if (!match) continue;
-      callsites.push({ clientRepo: client.descriptor.id, file: caller.file, line: caller.line, detector: caller.detector, match, runtimeObserved: caller.runtimeObserved === true, observedCount: caller.observedCount });
-    }
-    const affected = affectedForEndpoint(callsites, clients.map((item) => ({ id: item.descriptor.id, reverse: item.reverse })), {
-      maxImpactDepth: Math.max(0, Math.min(5, Number(input.maxImpactDepth) || 2)),
-      maxAffectedFiles: Math.max(1, Math.min(500, Number(input.maxAffectedFiles) || 100)), maxScreens: 50, maxModules: 50,
-    });
-    results.push({ ...server, callsites, affected, liveness: callsites.length ? "NOT_DEAD_EXTERNAL_USE" : "UNKNOWN" });
-  }
-  const uncertain = [
-    ...backend.uncertain.map((item) => ({ repository: input.backend.id, ...item })),
-    ...clients.flatMap((item) => item.evidence.uncertain.map((entry) => ({ repository: item.descriptor.id, ...entry }))),
-  ].filter(selected);
-  const reasons = [...backend.reasons, ...clients.flatMap((item) => item.evidence.reasons)];
-  if (uncertain.length) reasons.push(`${uncertain.length} dynamic/reflection contract expression(s) remain UNKNOWN`);
-  const runtimeReports = [
-    { repository: input.backend.id, ...backend.runtime },
-    ...clients.map((item) => ({ repository: item.descriptor.id, ...item.evidence.runtime })),
-  ];
-  const resolvedRuntime = backend.resolvedRuntime.length + clients.reduce((sum, item) => sum + item.evidence.resolvedRuntime.length, 0);
-  return {
-    transportContractsV: 2,
-    transport,
-    status: reasons.length ? "PARTIAL" : "COMPLETE",
-    completeness: { complete: reasons.length === 0, reasons: [...new Set(reasons)] },
-    totals: {
-      contracts: results.length,
-      matches: results.reduce((sum, item) => sum + item.callsites.length, 0),
-      uncertain: uncertain.length,
-      filesScanned: backend.filesScanned + clients.reduce((sum, item) => sum + item.evidence.filesScanned, 0),
-      runtimeObservations: runtimeReports.reduce((sum, item) => sum + item.observations.length, 0),
-      runtimeResolved: resolvedRuntime,
-      runtimeReportsComplete: runtimeReports.filter((item) => item.status === "COMPLETE").length,
-    },
-    contracts: results,
-    uncertain: uncertain.slice(0, 200),
-    runtimeEvidence: {
-      status: runtimeReports.every((item) => item.status === "COMPLETE") ? "COMPLETE" : "PARTIAL",
-      reports: runtimeReports.map(({ observations, reasons: reportReasons, ...report }) => ({ ...report, observationCount: observations.length, reasons: reportReasons })),
-      resolvedUnknowns: resolvedRuntime,
-    },
-  };
-}

package/src/analysis/transport-runtime-evidence.js

@@ -1,155 +0,0 @@
-import { readFileSync, statSync } from "node:fs";
-import { isAbsolute, relative, resolve } from "node:path";
-import { createRepoBoundary, isPathInside } from "../repo-path.js";
-
-const TRANSPORT_RUNTIME_SCHEMA = "weavatrix.transport-runtime.v1";
-const TRANSPORTS = ["graphql", "grpc", "event"];
-const DEFAULT_REPORTS = [
-  ".weavatrix/transport-runtime.json",
-  ".weavatrix/reports/transport-runtime.json",
-];
-const MAX_REPORT_BYTES = 2 * 1024 * 1024;
-const MAX_OBSERVATIONS = 10_000;
-
-const text = (value, max = 256) => typeof value === "string" ? value.trim().slice(0, max) : "";
-const number = (value) => Number.isFinite(Number(value)) ? Number(value) : undefined;
-
-function requestedTransports(transport) {
-  return TRANSPORTS.includes(transport) ? [transport] : TRANSPORTS;
-}
-
-function reportPath(descriptor, candidate) {
-  const boundary = createRepoBoundary(descriptor.repoRoot);
-  const resolved = boundary.resolve(candidate);
-  return resolved.ok ? { boundary, path: resolved.path } : { boundary, reason: resolved.reason };
-}
-
-function safeSourceFile(descriptor, value) {
-  const raw = text(value, 1024).replace(/\\/g, "/");
-  if (!raw || raw.includes("\0")) return undefined;
-  if (!isAbsolute(raw) && !raw.startsWith("../") && !raw.includes("/../")) return raw.replace(/^\.\//, "");
-  const root = resolve(descriptor.repoRoot);
-  const target = resolve(raw);
-  return isPathInside(root, target) ? relative(root, target).replace(/\\/g, "/") : undefined;
-}
-
-function attributeValue(attribute) {
-  const value = attribute?.value ?? attribute;
-  for (const key of ["stringValue", "intValue", "doubleValue", "boolValue"]) {
-    if (value?.[key] !== undefined) return value[key];
-  }
-  return typeof value === "string" || typeof value === "number" || typeof value === "boolean" ? value : undefined;
-}
-
-function attributes(input) {
-  const out = new Map();
-  for (const item of Array.isArray(input) ? input : []) if (typeof item?.key === "string") out.set(item.key, attributeValue(item));
-  return out;
-}
-
-function spanSide(span, transport) {
-  const kind = String(span?.kind ?? "").toUpperCase();
-  const numeric = Number(span?.kind);
-  if (transport === "event") {
-    if (kind.includes("PRODUCER") || numeric === 4) return "publisher";
-    if (kind.includes("CONSUMER") || numeric === 5) return "subscriber";
-  }
-  if (kind.includes("SERVER") || numeric === 2) return "server";
-  if (kind.includes("CLIENT") || numeric === 3) return "client";
-  return "";
-}
-
-function observationFromSpan(descriptor, span) {
-  const attrs = attributes(span?.attributes);
-  const common = {
-    file: safeSourceFile(descriptor, attrs.get("code.file.path") ?? attrs.get("code.filepath")),
-    line: number(attrs.get("code.line.number") ?? attrs.get("code.lineno")),
-    observedCount: 1,
-    detector: "otlp-span",
-  };
-  const rpcSystem = text(attrs.get("rpc.system")).toLowerCase();
-  if (rpcSystem === "grpc") {
-    const fallback = text(span?.name).split("/").filter(Boolean);
-    return { ...common, transport: "grpc", side: spanSide(span, "grpc"), service: text(attrs.get("rpc.service")) || fallback.at(-2), name: text(attrs.get("rpc.method")) || fallback.at(-1) };
-  }
-  const graphOperation = text(attrs.get("graphql.operation.type")).toUpperCase();
-  const graphField = text(attrs.get("graphql.field.name") ?? attrs.get("graphql.field"));
-  if (graphOperation || graphField) return { ...common, transport: "graphql", side: spanSide(span, "graphql"), operation: graphOperation, name: graphField };
-  const messagingSystem = text(attrs.get("messaging.system")).toLowerCase();
-  const destination = text(attrs.get("messaging.destination.name") ?? attrs.get("messaging.destination"));
-  if (messagingSystem || destination) return { ...common, transport: "event", side: spanSide(span, "event"), kind: text(attrs.get("messaging.operation.type") ?? attrs.get("messaging.operation")), name: destination };
-  return null;
-}
-
-function otlpObservations(descriptor, report) {
-  const root = report.otlp && typeof report.otlp === "object" ? report.otlp : report;
-  const out = [];
-  for (const resource of Array.isArray(root.resourceSpans) ? root.resourceSpans : []) {
-    const scopes = resource.scopeSpans ?? resource.instrumentationLibrarySpans ?? [];
-    for (const scope of scopes) for (const span of Array.isArray(scope.spans) ? scope.spans : []) {
-      const observation = observationFromSpan(descriptor, span);
-      if (observation) out.push(observation);
-    }
-  }
-  return out;
-}
-
-function normalizeObservation(descriptor, raw) {
-  const transport = text(raw?.transport).toLowerCase();
-  const side = text(raw?.side).toLowerCase();
-  const name = text(raw?.name);
-  if (!TRANSPORTS.includes(transport) || !name) return null;
-  const allowedSides = transport === "event" ? ["publisher", "subscriber"] : ["server", "client", "server-call"];
-  if (!allowedSides.includes(side)) return null;
-  const operation = text(raw?.operation).toUpperCase();
-  if (transport === "graphql" && !["QUERY", "MUTATION", "SUBSCRIPTION"].includes(operation)) return null;
-  const line = number(raw?.line);
-  return {
-    transport, side, name,
-    ...(operation ? { operation } : {}),
-    ...(text(raw?.service) ? { service: text(raw.service) } : {}),
-    ...(text(raw?.kind) ? { kind: text(raw.kind) } : {}),
-    ...(safeSourceFile(descriptor, raw?.file) ? { file: safeSourceFile(descriptor, raw.file) } : {}),
-    ...(line > 0 && line <= 10_000_000 ? { line: Math.floor(line) } : {}),
-    observedCount: Math.max(1, Math.min(1_000_000_000, Math.floor(number(raw?.observedCount) || 1))),
-    detector: text(raw?.detector) || "runtime-report",
-    runtimeObserved: true,
-  };
-}
-
-function validateReport(descriptor, report, options, file) {
-  const reasons = [];
-  let usable = true;
-  if (report?.schema !== TRANSPORT_RUNTIME_SCHEMA) { reasons.push(`${descriptor.id}: unsupported runtime evidence schema`); usable = false; }
-  if (!descriptor.graph?.graphRevision || report?.repositoryRevision !== descriptor.graph.graphRevision) { reasons.push(`${descriptor.id}: runtime evidence revision does not match the active graph`); usable = false; }
-  const generatedAt = Date.parse(report?.generatedAt);
-  const now = Number(options.now ?? Date.now());
-  const maxAgeMs = Math.max(1, Math.min(8760, Number(options.maxAgeHours) || 168)) * 3_600_000;
-  if (!Number.isFinite(generatedAt)) { reasons.push(`${descriptor.id}: runtime evidence generatedAt is invalid`); usable = false; }
-  else if (generatedAt > now + 300_000 || now - generatedAt > maxAgeMs) { reasons.push(`${descriptor.id}: runtime evidence is stale or from the future`); usable = false; }
-  const selected = requestedTransports(options.transport);
-  const coverage = Object.fromEntries(selected.map((item) => [item, String(report?.coverage?.[item] || "NOT_CHECKED").toUpperCase()]));
-  for (const [item, status] of Object.entries(coverage)) if (status !== "COMPLETE") reasons.push(`${descriptor.id}: ${item} runtime capture is ${status}`);
-  const raw = [...(Array.isArray(report?.observations) ? report.observations : []), ...otlpObservations(descriptor, report)].slice(0, MAX_OBSERVATIONS);
-  const observations = usable ? raw.map((item) => normalizeObservation(descriptor, item)).filter(Boolean) : [];
-  if (raw.length !== observations.length) reasons.push(`${descriptor.id}: ${raw.length - observations.length} invalid runtime observation(s) were ignored`);
-  return { status: reasons.length ? "PARTIAL" : "COMPLETE", file, generatedAt: report?.generatedAt, repositoryRevision: report?.repositoryRevision, coverage, observations, reasons };
-}
-
-export function loadTransportRuntimeEvidence(descriptor, options = {}) {
-  const candidates = options.file ? [String(options.file)] : DEFAULT_REPORTS;
-  for (const candidate of candidates) {
-    const resolved = reportPath(descriptor, candidate);
-    if (!resolved.path) {
-      if (options.file) return { status: "ERROR", file: candidate, coverage: {}, observations: [], reasons: [`${descriptor.id}: runtime evidence path is ${resolved.reason}`] };
-      continue;
-    }
-    try {
-      if (statSync(resolved.path).size > MAX_REPORT_BYTES) return { status: "ERROR", file: candidate, coverage: {}, observations: [], reasons: [`${descriptor.id}: runtime evidence exceeds ${MAX_REPORT_BYTES} bytes`] };
-      return validateReport(descriptor, JSON.parse(readFileSync(resolved.path, "utf8")), options, candidate);
-    } catch {
-      return { status: "ERROR", file: candidate, coverage: {}, observations: [], reasons: [`${descriptor.id}: runtime evidence is unreadable or invalid JSON`] };
-    }
-  }
-  return { status: "NOT_CHECKED", file: null, coverage: {}, observations: [], reasons: [`${descriptor.id}: no revision-bound runtime transport evidence was found`] };
-}