weavatrix 0.3.13 → 1.0.0

package/src/mcp/tools-architecture.mjs

@@ -1,177 +0,0 @@
-// Executable target architecture for agents: read the active contract before a change, then run the
-// same deterministic verifier after it. No tool silently edits policy or accepts debt.
-import {contractForChange, normalizeArchitectureContract, verifyArchitecture} from '../analysis/architecture-contract.js'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-import {detectRepoStack} from '../scan/discover.js'
-import {toolResult} from './tool-result.mjs'
-
-const version = new URL(import.meta.url).search
-const load = (path) => import(new URL(`${path}${version}`, import.meta.url).href)
-const [starter, bootstrap] = await Promise.all([
-    load('./architecture-starter.mjs'),
-    load('./architecture-bootstrap.mjs'),
-])
-const {createArchitectureStarter, PROVISIONAL_BUDGETS} = starter
-export const tBootstrapArchitecture = bootstrap.tBootstrapArchitecture
-const activeContract = bootstrap.activeArchitectureContract
-
-const remediation = () => ({
-    offlinePath: '.weavatrix/architecture.json',
-    extensionAction: 'A composing extension may provide owner-approved remote contract storage',
-    nextTool: 'verify_architecture',
-})
-
-const stackIds = (repoRoot) => {
-    try {
-        const stack = detectRepoStack(repoRoot)
-        return ['languages', 'runtimes', 'tests', 'infra', 'deploy']
-            .flatMap((category) => (Array.isArray(stack?.[category]) ? stack[category] : []))
-            .map((item) => String(item?.id || '')).filter(Boolean)
-    } catch { return [] }
-}
-
-function notConfiguredResult(g, action, {includeStarter = false, repoRoot = null} = {}) {
-    const proposal = includeStarter ? createArchitectureStarter(g, repoRoot) : null
-    const starter = proposal?.contract || null
-    const starterText = starter
-        ? ` A source-free starter with ${starter.components.length} product-code territories is available in JSON output from this lookup.`
-        : ''
-    return toolResult([
-        `Architecture ${action} is NOT_CONFIGURED — no target contract is active.${starterText}`,
-        'Next: save .weavatrix/architecture.json, then call verify_architecture.',
-    ].join('\n'), {
-        state: 'NOT_CONFIGURED',
-        remediation: remediation(),
-        ...(starter ? {
-            starterSummary: {
-                components: starter.components.length, budgets: starter.budgets,
-                observedDependencyDirections: proposal.observedDependencyProposals.length,
-                candidateBudgetsNotEnforced: proposal.budgetProposals.length,
-            },
-            starterContract: starter,
-            observedDependencyProposals: proposal.observedDependencyProposals,
-            budgetProposals: proposal.budgetProposals,
-            starterMethodology: proposal.methodology,
-        } : {}),
-    })
-}
-
-function classifyChangeFiles(files, repoRoot) {
-    const classifier = createPathClassifier(repoRoot)
-    const normalized = [...new Set((Array.isArray(files) ? files : [])
-        .slice(0, 200)
-        .map((file) => String(file || '').replace(/\\/g, '/').replace(/^\.\//, ''))
-        .filter((file) => file && !file.startsWith('../') && !file.includes('/../')))]
-        .sort((a, b) => a.localeCompare(b))
-    const testOnlyFiles = normalized.filter((file) => hasPathClass(classifier.explain(file), 'test', 'e2e'))
-    const testOnly = new Set(testOnlyFiles)
-    return {files: normalized, productFiles: normalized.filter((file) => !testOnly.has(file)), testOnlyFiles}
-}
-
-function provisionalPreflight(g, args, ctx) {
-    const surfaces = classifyChangeFiles(args?.files, ctx?.repoRoot)
-    const intent = String(args?.intent || '').slice(0, 500)
-    const budgetText = [
-        `no new runtime cycles (baseline ${PROVISIONAL_BUDGETS.runtimeCycles})`,
-        `file <= ${PROVISIONAL_BUDGETS.maxFileLoc} LOC`,
-        `function <= ${PROVISIONAL_BUDGETS.maxFunctionLoc} LOC`,
-        `cyclomatic <= ${PROVISIONAL_BUDGETS.maxCyclomatic}`,
-    ].join('; ')
-    return toolResult([
-        `Architecture preflight is NOT_CONFIGURED for ${surfaces.files.length} file(s)${intent ? ` — ${intent}` : ''}.`,
-        `Provisional no-regression guidance (not enforced policy): ${budgetText}.`,
-        `${surfaces.productFiles.length} product file(s); ${surfaces.testOnlyFiles.length} test-only file(s). Save a target contract to make these budgets enforceable.`,
-    ].join('\n'), {
-        state: 'NOT_CONFIGURED',
-        guidance: 'PROVISIONAL_BUDGETS',
-        enforceable: false,
-        intent,
-        ...surfaces,
-        provisionalBudgets: PROVISIONAL_BUDGETS,
-        remediation: remediation(),
-    })
-}
-
-export function tGetArchitectureContract(g, args, ctx) {
-    if (args?.action === 'preview' || args?.action === 'approve') return tBootstrapArchitecture(g, args, ctx)
-    const loaded = activeContract(ctx)
-    if (!loaded.contract) {
-        const text = loaded.error
-            ? `Architecture contract is invalid (${loaded.source || 'unknown'}): ${loaded.error}`
-            : 'No target architecture contract is active.'
-        if (!loaded.error) return notConfiguredResult(g, 'lookup', {includeStarter: true, repoRoot: ctx?.repoRoot})
-        return toolResult(text, {state: 'ERROR', source: loaded.source, error: loaded.error})
-    }
-    const contract = loaded.contract
-    return toolResult([
-        `Target architecture: ${contract.name} (${contract.style}, ${contract.enforcement}).`,
-        `Contract ${contract.contractHash.slice(0, 12)} from ${loaded.source}; ${contract.components.length} components, ${contract.dependencyRules.length} dependency rules.`,
-        `Quality budgets: ${Object.entries(contract.budgets).map(([key, value]) => `${key}=${value}`).join(', ') || '(none)'}.`,
-    ].join('\n'), {state: 'ACTIVE', source: loaded.source, contract})
-}
-
-export function tPrepareChange(g, args = {}, ctx) {
-    const loaded = activeContract(ctx)
-    if (!loaded.contract) return provisionalPreflight(g, args, ctx)
-    const prepared = contractForChange(loaded.contract, args.files)
-    const surfaces = classifyChangeFiles(prepared.files, ctx?.repoRoot)
-    const intent = String(args.intent || '').slice(0, 500)
-    return toolResult([
-        `Architecture preflight for ${prepared.files.length} file(s)${intent ? ` — ${intent}` : ''}.`,
-        `Affected target components: ${prepared.components.join(', ') || '(unmapped)'}.`,
-        ...(surfaces.testOnlyFiles.length ? [`Test-only surface: ${surfaces.testOnlyFiles.join(', ')}.`] : []),
-        `Applicable rules: ${prepared.rules.map((rule) => rule.id).join(', ') || '(none)'}.`,
-        'Run verify_architecture after the edit; do not silently add an exception or rewrite the target contract.',
-    ].join('\n'), {state: 'READY', intent, contractHash: loaded.contract.contractHash, ...prepared, productFiles: surfaces.productFiles, testOnlyFiles: surfaces.testOnlyFiles})
-}
-
-export function tVerifyArchitecture(g, args, ctx) {
-    const loaded = activeContract(ctx)
-    if (!loaded.contract) return notConfiguredResult(g, 'verification')
-    const verification = verifyArchitecture({graph: g, contract: loaded.contract, technologies: stackIds(ctx.repoRoot)})
-    const groups = [['new', verification.new], ['existing', verification.existing], ['fixed', verification.fixed], ['excepted', verification.excepted]]
-    const lines = [
-        `Architecture verify: ${verification.status} (${verification.enforcement}; contract ${verification.contractHash.slice(0, 12)}).`,
-        `New ${verification.new.length} · existing debt ${verification.existing.length} · fixed ${verification.fixed.length} · excepted ${verification.excepted.length}.`,
-        ...groups.filter(([, values]) => values.length).flatMap(([label, values]) => [
-            `${label}:`,
-            ...values.slice(0, 20).map((item) => typeof item === 'string' ? `  ${item}` : `  ${item.ruleId}: ${item.evidence}${item.current != null ? ` (${item.current} > ${item.target})` : ''}`),
-        ]),
-    ]
-    return toolResult(lines.join('\n'), {state: verification.status, source: loaded.source, verification}, {
-        completeness: {violationsReturned: Math.min(20, verification.new.length + verification.existing.length), violationsTotal: verification.new.length + verification.existing.length},
-    })
-}
-
-export function tExplainArchitectureViolation(g, args, ctx) {
-    const loaded = activeContract(ctx)
-    if (!loaded.contract) return toolResult('No active architecture contract.', {state: 'NOT_CONFIGURED'})
-    const verification = verifyArchitecture({graph: g, contract: loaded.contract, technologies: stackIds(ctx.repoRoot)})
-    const fingerprint = String(args.fingerprint || '')
-    const item = [...verification.new, ...verification.existing, ...verification.excepted]
-        .find((entry) => entry.fingerprint === fingerprint)
-    if (!item) return toolResult(`Violation ${fingerprint || '(missing)'} is not active in the current verification.`, {state: 'NOT_FOUND', fingerprint})
-    const rule = loaded.contract.dependencyRules.find((candidate) => candidate.id === item.ruleId)
-    return toolResult([
-        `${item.ruleId}: ${item.evidence}.`,
-        rule?.reason ? `Reason: ${rule.reason}` : 'The finding violates an explicit dependency or quality rule in the active target contract.',
-        'Preferred action: change the dependency/metric. If that is intentionally impossible, propose a time-bounded exception for human review.',
-    ].join('\n'), {state: 'ACTIVE', violation: item, rule: rule || null})
-}
-
-export function tProposeArchitectureException(g, args, ctx) {
-    const loaded = activeContract(ctx)
-    if (!loaded.contract) return toolResult('No active architecture contract.', {state: 'NOT_CONFIGURED'})
-    const verification = verifyArchitecture({graph: g, contract: loaded.contract, technologies: stackIds(ctx.repoRoot)})
-    const item = [...verification.new, ...verification.existing].find((entry) => entry.fingerprint === String(args.fingerprint || ''))
-    if (!item) return toolResult('Only an active violation can be proposed as an exception.', {state: 'NOT_FOUND'})
-    const proposal = {
-        fingerprint: item.fingerprint,
-        reason: String(args.reason || '').trim().slice(0, 300),
-        ...(args.expires ? {expires: String(args.expires)} : {}),
-    }
-    const checked = normalizeArchitectureContract({...loaded.contract, exceptions: [...loaded.contract.exceptions, proposal]})
-    const normalized = checked.exceptions.find((entry) => entry.fingerprint === item.fingerprint)
-    if (!normalized || !normalized.reason) return toolResult('A non-empty reason and optional YYYY-MM-DD expiry are required.', {state: 'INVALID'})
-    return toolResult('Exception proposal prepared for human review; the contract was not changed.', {state: 'PROPOSED', proposal: normalized, contractHash: loaded.contract.contractHash})
-}

package/src/mcp/tools-company.mjs

@@ -1,251 +0,0 @@
-// Cross-repository HTTP contract intelligence. Repository paths are resolved only through the
-// local global registry; callers can select an opaque repository UUID or an unambiguous label but
-// can never pass an arbitrary filesystem path through this tool.
-import {analyzeHttpContracts} from '../analysis/http-contracts.js'
-import {analyzeTransportContracts} from '../analysis/transport-contracts.js'
-import {graphHomeDir} from '../graph/layout.js'
-import {liveRepositoryRecords} from '../graph/repo-registry.js'
-import {ContractCursorError, paginateContractEvidence} from './company-contract-page.mjs'
-import {publicRecord, reconcileGraph} from './company-contract-reconcile.mjs'
-import {toolResult} from './tool-result.mjs'
-import {contractVerdict, contractVerdictLine} from './company-contract-verdict.mjs'
-
-const CROSS_REPO_HTTP_CONTRACT_V = 4
-const selectorText = (value) => String(value ?? '').trim()
-
-function selectRecord(records, selector) {
-    const query = selectorText(selector)
-    if (!query) return {error: 'repository selector is required'}
-    const byId = records.find((record) => record.repositoryId === query)
-    if (byId) return {record: byId}
-    const byLabel = records.filter((record) => String(record.label || '').toLowerCase() === query.toLowerCase())
-    if (byLabel.length === 1) return {record: byLabel[0]}
-    if (byLabel.length > 1) return {
-        error: `repository label "${query}" is ambiguous; use one of these repository IDs`,
-        candidates: byLabel.map((record) => ({repositoryId: record.repositoryId, label: record.label})),
-    }
-    return {error: `repository "${query}" is not present in the live global graph registry`}
-}
-
-function safeAlias(record, records) {
-    const base = String(record.label || 'repo').normalize('NFKC')
-        .replace(/[^a-z0-9._-]+/gi, '-').replace(/^-+|-+$/g, '').slice(0, 56) || 'repo'
-    const duplicates = records.filter((item) => String(item.label || '').toLowerCase() === String(record.label || '').toLowerCase())
-    return duplicates.length > 1 ? `${base}-${String(record.repositoryId).slice(0, 8)}` : base
-}
-
-export async function tTraceApiContract(_g, args = {}, ctx = {}) {
-    const graphHome = ctx.graphHome || graphHomeDir()
-    const records = liveRepositoryRecords(graphHome)
-    if (!records.length) return toolResult(
-        'VERDICT NOT_CONFIGURED — the global repository registry has no live graphs. Open/build both the backend and client repositories first.',
-        {status: 'NOT_CONFIGURED', availableRepositories: []},
-    )
-
-    const backendSelection = selectRecord(records, args.backend)
-    if (!backendSelection.record) return toolResult(
-        `VERDICT INVALID_REPOSITORY — ${backendSelection.error}.`,
-        {status: 'INVALID_REPOSITORY', role: 'backend', ...backendSelection, availableRepositories: records.map((record) => publicRecord(record, safeAlias(record, records)))},
-    )
-    const rawClients = Array.isArray(args.clients) ? args.clients.slice(0, 20) : []
-    if (!rawClients.length) return toolResult(
-        'VERDICT INVALID_REPOSITORY — at least one client repository ID or label is required.',
-        {status: 'INVALID_REPOSITORY', role: 'clients'},
-    )
-    const clientRecords = []
-    for (const selector of rawClients) {
-        const selected = selectRecord(records, selector)
-        if (!selected.record) return toolResult(
-            `VERDICT INVALID_REPOSITORY — ${selected.error}.`,
-            {status: 'INVALID_REPOSITORY', role: 'client', selector, ...selected},
-        )
-        if (!clientRecords.some((record) => record.repositoryId === selected.record.repositoryId)) clientRecords.push(selected.record)
-    }
-    if (clientRecords.some((record) => record.repositoryId === backendSelection.record.repositoryId)) return toolResult(
-        'VERDICT INVALID_REPOSITORY — backend and client selections must be distinct repositories.',
-        {status: 'INVALID_REPOSITORY', role: 'clients'},
-    )
-
-    const backend = backendSelection.record
-    const backendAlias = safeAlias(backend, records)
-    const clients = clientRecords.map((record) => ({record, alias: safeAlias(record, records)}))
-    const reconciled = []
-    for (const selected of [
-        {record: backend, alias: backendAlias, role: 'backend'},
-        ...clients.map(({record, alias}) => ({record, alias, role: 'client'})),
-    ]) {
-        reconciled.push(await reconcileGraph(selected.record, selected.alias, selected.role, graphHome))
-    }
-    const backendGraph = reconciled[0]
-    const clientGraphs = reconciled.slice(1)
-    const reconciliationReasons = reconciled.filter((item) => item.reason).map((item) => item.reason)
-    const graphReconciliation = reconciled.map((item) => item.publicStatus)
-    if (!backendGraph.graph || clientGraphs.some((item) => !item.graph)) {
-        const reasons = reconciliationReasons.length ? reconciliationReasons : ['one or more selected graphs could not be refreshed and loaded']
-        const completeness = {complete: false, status: 'PARTIAL', reasons}
-        return toolResult(
-            `VERDICT PARTIAL — selected repository graphs could not all be refreshed and loaded.\nCompleteness: partial — ${reasons.join('; ')}.`,
-            {
-                crossRepoHttpContractV: CROSS_REPO_HTTP_CONTRACT_V,
-                status: 'PARTIAL',
-                repositories: {
-                    backend: publicRecord(backend, backendAlias),
-                    clients: clients.map(({record, alias}) => publicRecord(record, alias)),
-                },
-                graphReconciliation,
-                completeness,
-            },
-            {completeness, warnings: [{code: 'CROSS_REPO_GRAPH_REFRESH_PARTIAL', message: reasons.join('; ')}]},
-        )
-    }
-
-    try {
-        let analysis = analyzeHttpContracts({
-            backend: {id: backendAlias, repoRoot: backend.repoPath, graph: backendGraph.graph},
-            clients: clientGraphs.map((item) => ({id: item.alias, repoRoot: item.record.repoPath, graph: item.graph})),
-            method: args.method,
-            path: args.path,
-            changedFiles: args.changed_files,
-            includeTests: args.include_tests === true,
-            clientNames: args.client_names,
-            wrappers: args.client_wrappers,
-            autoDiscoverWrappers: args.auto_discover_wrappers !== false,
-            maxImpactDepth: args.max_impact_depth,
-            maxEndpoints: args.max_endpoints,
-            maxMatches: args.max_matches,
-            maxAffectedFiles: args.max_affected_files,
-            runtimeValues: args.runtime_config,
-        })
-        const selectedTransport = ['all', 'http', 'graphql', 'grpc', 'event'].includes(args.transport) ? args.transport : 'all'
-        if (!['all', 'http'].includes(selectedTransport)) analysis = {
-            ...analysis, status: 'complete', completeness: {complete: true, reasons: []}, endpoints: [], uncertain: [],
-            totals: {...analysis.totals, endpoints: 0, clientCalls: 0, matches: 0, methodMismatches: 0, uncertainCalls: 0, notDeadExternalUse: 0, notDeadExternalHandlers: 0, possibleExternalUse: 0, unknownLiveness: 0},
-        }
-        const transportAnalysis = selectedTransport === 'http'
-            ? {transportContractsV: 2, transport: 'http', status: 'COMPLETE', completeness: {complete: true, reasons: []}, totals: {contracts: 0, matches: 0, uncertain: 0, filesScanned: 0, runtimeObservations: 0, runtimeResolved: 0, runtimeReportsComplete: 0}, contracts: [], uncertain: [], runtimeEvidence: {status: 'NOT_APPLICABLE', reports: [], resolvedUnknowns: 0}}
-            : analyzeTransportContracts({
-                backend: {id: backendAlias, repoRoot: backend.repoPath, graph: backendGraph.graph},
-                clients: clientGraphs.map((item) => ({id: item.alias, repoRoot: item.record.repoPath, graph: item.graph})),
-                transport: selectedTransport === 'all' ? 'all' : selectedTransport,
-                includeTests: args.include_tests === true,
-                maxImpactDepth: args.max_impact_depth,
-                maxAffectedFiles: args.max_affected_files,
-                runtimeEvidenceFiles: args.runtime_evidence_files,
-                runtimeEvidenceMaxAgeHours: args.runtime_evidence_max_age_hours,
-            })
-        const verdict = contractVerdict(analysis, transportAnalysis)
-        const reasons = [...new Set([...reconciliationReasons, ...(analysis.completeness?.reasons || []), ...(transportAnalysis.completeness?.reasons || [])])]
-        const completeness = {
-            complete: reasons.length === 0 && analysis.completeness?.complete === true,
-            status: reasons.length === 0 && analysis.completeness?.complete === true ? 'COMPLETE' : 'PARTIAL',
-            reasons,
-        }
-        const topN = Math.max(1, Math.min(50, Number(args.top_n) || 10))
-        const ranked = [...analysis.endpoints].sort((left, right) =>
-            right.callsites.length - left.callsites.length ||
-            right.affected.files.length - left.affected.files.length ||
-            left.path.localeCompare(right.path))
-        const lines = [
-            contractVerdictLine(verdict, analysis.totals.endpoints + transportAnalysis.totals.contracts),
-            `Scope: ${backend.label} → ${clients.map(({record}) => record.label).join(', ')}; ${analysis.totals.endpoints} HTTP endpoint(s), ${transportAnalysis.totals.contracts} GraphQL/gRPC/event contract(s), ${analysis.totals.clientCalls} inspected HTTP call(s), ${verdict.uncertainCalls} uncertain.`,
-            ...ranked.slice(0, topN).flatMap((endpoint) => {
-                const location = endpoint.file ? ` (${endpoint.backend}:${endpoint.file}${endpoint.line ? `:${endpoint.line}` : ''})` : ''
-                const callsites = endpoint.callsites.slice(0, 3)
-                    .map((call) => `    caller ${call.clientRepo}:${call.file}:${call.line} (${call.match.confidence}, ${call.match.kind})`)
-                const screens = endpoint.affected.screens.slice(0, 3)
-                    .map((screen) => `    screen ${screen.client}:${screen.file} (distance ${screen.distance})`)
-                return [
-                    `  ${endpoint.method} ${endpoint.path}${location} [${endpoint.liveness.status}${endpoint.handler ? `; handler ${endpoint.handler}` : ''}] → ${endpoint.callsites.length} callsite(s), ${endpoint.affected.screens.length} screen(s), ${endpoint.affected.files.length} affected file(s)`,
-                    ...callsites,
-                    ...screens,
-                ]
-            }),
-            // Mismatch-only endpoints rarely rank into top_n (zero callsites), yet they drive the
-            // *_METHOD_MISMATCH verdicts — always surface them, citing the verdict's own total.
-            ...(analysis.totals.methodMismatches > 0 ? [
-                `  Method mismatches (${verdict.methodMismatches} call(s)):`,
-                ...analysis.endpoints.filter((endpoint) => endpoint.methodMismatches > 0).slice(0, 5).flatMap((endpoint) => [
-                    `    ${endpoint.method} ${endpoint.path} — ${endpoint.methodMismatches} call(s) use a different method`,
-                    ...(endpoint.methodMismatchSites || []).slice(0, 2).map((site) => `      caller ${site.clientRepo}:${site.file}:${site.line} uses ${site.method}`),
-                ]),
-            ] : []),
-            ...transportAnalysis.contracts.filter((contract) => contract.callsites.length).slice(0, topN).map((contract) =>
-                `  ${contract.transport.toUpperCase()} ${contract.service ? `${contract.service}.` : contract.operation ? `${contract.operation} ` : ''}${contract.name} (${contract.file}:${contract.line}) [${contract.liveness}] → ${contract.callsites.length} callsite(s), ${contract.affected.files.length} affected file(s)`),
-            completeness.complete
-                ? 'Completeness: complete within the declared repository graphs, supported static models and fresh revision-bound runtime capture.'
-                : `Completeness: partial — ${completeness.reasons.join('; ')}.`,
-        ]
-        let evidencePage
-        try {
-            evidencePage = paginateContractEvidence({
-                analysis,
-                transportAnalysis,
-                args,
-                fingerprintParts: [
-                    backend.repositoryId,
-                    backendGraph.graph?.graphRevision || null,
-                    ...clientGraphs.flatMap((item) => [item.record.repositoryId, item.graph?.graphRevision || null]),
-                    selectedTransport,
-                    args.method || null,
-                    args.path || null,
-                    Array.isArray(args.changed_files) ? [...args.changed_files].sort() : [],
-                    args.include_tests === true,
-                ],
-            })
-        } catch (error) {
-            if (!(error instanceof ContractCursorError)) throw error
-            return toolResult(
-                `VERDICT INVALID_CURSOR — ${error.message}. Restart from the first page without cursor.`,
-                {status: 'INVALID_CURSOR', code: error.code, reason: error.message},
-                {page: {status: 'INVALID_CURSOR'}},
-            )
-        }
-        const transportSummary = {
-            transportContractsV: transportAnalysis.transportContractsV,
-            transport: transportAnalysis.transport,
-            status: transportAnalysis.status,
-            completeness: transportAnalysis.completeness,
-            totals: transportAnalysis.totals,
-            runtimeEvidence: transportAnalysis.runtimeEvidence,
-        }
-        const result = {
-            crossRepoHttpContractV: CROSS_REPO_HTTP_CONTRACT_V,
-            verdict,
-            repositories: {
-                backend: publicRecord(backend, backendAlias),
-                clients: clients.map(({record, alias}) => publicRecord(record, alias)),
-            },
-            httpContractsV: analysis.httpContractsV,
-            filters: analysis.filters,
-            limits: analysis.limits,
-            totals: analysis.totals,
-            wrapperDiscovery: analysis.wrapperDiscovery,
-            transportContracts: transportSummary,
-            evidencePage,
-            status: completeness.status,
-            graphReconciliation,
-            completeness,
-        }
-        return toolResult(lines.join('\n'), result, {
-            completeness,
-            page: {
-                detail: evidencePage.detail,
-                offset: evidencePage.offset,
-                pageSize: evidencePage.pageSize,
-                totalItems: evidencePage.totalItems,
-                returnedItems: evidencePage.returnedItems,
-                hasMore: evidencePage.hasMore,
-                nextCursor: evidencePage.nextCursor,
-            },
-            warnings: completeness.complete ? [] : [{code: 'CROSS_REPO_ANALYSIS_PARTIAL', message: completeness.reasons.join('; ')}],
-        })
-    } catch (error) {
-        const reason = error instanceof Error ? error.message : 'cross-repository analysis failed'
-        const completeness = {complete: false, status: 'PARTIAL', reasons: [reason]}
-        return toolResult(
-            `VERDICT PARTIAL — ${reason}.`,
-            {status: 'PARTIAL', graphReconciliation, completeness},
-            {completeness, warnings: [{code: 'CROSS_REPO_ANALYSIS_PARTIAL', message: reason}]},
-        )
-    }
-}

package/src/mcp/tools-context.mjs

@@ -1,222 +0,0 @@
-import {isStructuralRelation} from '../graph/relations.js'
-import {boundedInteger} from '../bounds.js'
-import {isSymbol, labelOf} from './graph-context.mjs'
-import {toolResult} from './tool-result.mjs'
-import {sourceExcerpt} from './tools-source.mjs'
-import {createPathClassifier, hasPathClass} from '../path-classification.js'
-
-const MAX_LINE_SAMPLES = 5
-const CONTEXT_NON_PRODUCT = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
-
-const fileOf = (g, id) => {
-    const node = g.byId.get(String(id))
-    return String(node?.source_file || (isSymbol(id) ? String(id).split('#')[0] : id))
-}
-
-function aggregateEdges(g, edges, cap, {
-    callsiteFile = null, classifier = null, includeClassified = true, productionFirst = false,
-} = {}) {
-    const groups = new Map()
-    for (const edge of edges || []) {
-        if (isStructuralRelation(edge.relation) || edge.barrelProxy === true) continue
-        const id = String(edge.id)
-        const relation = String(edge.relation || 'references')
-        const key = `${id}\0${relation}`
-        let group = groups.get(key)
-        if (!group) {
-            const targetFile = fileOf(g, id)
-            group = {
-                id, label: labelOf(g, id), relation, count: 0, lines: [],
-                file: callsiteFile || targetFile,
-                ...(callsiteFile && callsiteFile !== targetFile ? {targetFile} : {}),
-            }
-            groups.set(key, group)
-        }
-        group.count++
-        if (Number.isInteger(edge.line) && group.lines.length < MAX_LINE_SAMPLES && !group.lines.includes(edge.line)) group.lines.push(edge.line)
-        if (edge.typeOnly === true) group.typeOnly = true
-        if (edge.compileOnly === true) group.compileOnly = true
-    }
-    const all = [...groups.values()]
-    if (classifier) for (const group of all) {
-        const info = classifier.explain(group.file, {content: ''})
-        const classes = CONTEXT_NON_PRODUCT.filter((name) => hasPathClass(info, name))
-        group.classified = classes.length > 0 || info?.excluded === true
-        if (classes.length) group.pathClasses = classes
-    }
-    const eligible = includeClassified ? all : all.filter((group) => !group.classified)
-    eligible.sort((left, right) => (productionFirst ? Number(left.classified) - Number(right.classified) : 0)
-        || right.count - left.count || left.file.localeCompare(right.file) || left.id.localeCompare(right.id))
-    return {
-        total: eligible.length,
-        available: all.length,
-        suppressed: all.length - eligible.length,
-        shown: eligible.slice(0, cap),
-        capped: eligible.length > cap,
-    }
-}
-
-const sameOrigin = (occurrence, definition) => occurrence.originId === definition.id
-    || (occurrence.originFile === definition.file && occurrence.originName === definition.name)
-
-function exactReExportSites(g, definition, cap) {
-    const occurrences = Array.isArray(g.reExportOccurrences) ? g.reExportOccurrences : []
-    const exposures = new Map()
-    if (definition.exported) exposures.set(definition.file, new Set([definition.name]))
-    const shown = new Map()
-    const add = (occurrence, exported = occurrence.exported) => {
-        const key = `${occurrence.file}\0${occurrence.line}\0${exported}\0${occurrence.kind}`
-        if (shown.has(key)) return false
-        shown.set(key, {
-            file: occurrence.file,
-            line: occurrence.line,
-            kind: occurrence.kind,
-            exported,
-            imported: occurrence.imported,
-            targetFile: occurrence.targetFile,
-            typeOnly: occurrence.typeOnly === true,
-            ...(occurrence.specifier ? {specifier: occurrence.specifier} : {}),
-            ...(occurrence.originFile ? {originFile: occurrence.originFile, originName: occurrence.originName} : {}),
-        })
-        return true
-    }
-    for (let pass = 0; pass <= occurrences.length; pass++) {
-        let changed = false
-        for (const occurrence of occurrences) {
-            if (occurrence.kind === 'star') {
-                const names = exposures.get(occurrence.targetFile)
-                if (!names) continue
-                for (const name of names) {
-                    if (name === 'default') continue
-                    changed = add(occurrence, name) || changed
-                    let exported = exposures.get(occurrence.file)
-                    if (!exported) exposures.set(occurrence.file, (exported = new Set()))
-                    const before = exported.size
-                    exported.add(name)
-                    changed = exported.size !== before || changed
-                }
-                continue
-            }
-            if (!sameOrigin(occurrence, definition)) continue
-            changed = add(occurrence) || changed
-            if (occurrence.kind !== 'namespace') {
-                let exported = exposures.get(occurrence.file)
-                if (!exported) exposures.set(occurrence.file, (exported = new Set()))
-                const before = exported.size
-                exported.add(occurrence.exported)
-                changed = exported.size !== before || changed
-            }
-        }
-        if (!changed) break
-    }
-    const all = [...shown.values()].sort((left, right) => left.file.localeCompare(right.file)
-        || left.line - right.line || left.exported.localeCompare(right.exported))
-    return {total: all.length, shown: all.slice(0, cap), capped: all.length > cap}
-}
-
-function linesForGroups(title, groups) {
-    const suppression = groups.suppressed ? `; ${groups.suppressed} classified container(s) suppressed` : ''
-    if (!groups.shown.length) return [`${title}: none${suppression}`]
-    const lines = [`${title}: ${groups.total} container(s)${groups.capped ? ` (${groups.shown.length} shown)` : ''}${suppression}`]
-    for (const group of groups.shown) {
-        const sites = group.lines.length ? `:${group.lines.join(',')}` : ''
-        const destination = group.targetFile ? ` → ${group.targetFile}` : ''
-        const classified = group.classified ? ` [classified${group.pathClasses?.length ? `:${group.pathClasses.join('+')}` : ''}]` : ''
-        lines.push(`  ${group.count}× ${group.relation}  ${group.label}  [call site ${group.file}${sites}${destination}]${classified}`)
-    }
-    return lines
-}
-
-function textFor(result) {
-    if (result.status !== 'OK') return result.text || `Context bundle: ${result.status}`
-    const definition = result.definition
-    const lines = [
-        `Context bundle: ${definition.label}  [${definition.id}]`,
-        `Definition: ${definition.file}:${definition.line} (${definition.kind}, ${definition.space} space)`,
-        `Evidence: ${result.evidence.state}; ${result.references.occurrences} exact reference occurrence(s) in ${result.references.files} file(s).`,
-        ...linesForGroups('Inbound', result.inbound),
-        ...linesForGroups('Outbound', result.outbound),
-        `Re-export sites: ${result.reExports.total}${result.reExports.capped ? ` (${result.reExports.shown.length} shown)` : ''}`,
-    ]
-    for (const site of result.reExports.shown) lines.push(`  ${site.file}:${site.line}  ${site.kind} ${site.imported} → ${site.exported}${site.typeOnly ? ' [type]' : ''}`)
-    for (const source of result.source) lines.push('', `${source.role} source (${source.file}:${source.startLine}-${source.endLine}):`, source.text)
-    return lines.join('\n')
-}
-
-export async function tContextBundle(g, args = {}, ctx = {}, inspectSymbol) {
-    if (typeof inspectSymbol !== 'function') throw new Error('context_bundle requires inspect_symbol support')
-    const maxRelated = boundedInteger(args.max_related, 10, 1, 30)
-    const maxReExports = boundedInteger(args.max_reexports, 20, 1, 100)
-    const maxSourceFiles = boundedInteger(args.max_source_files, 4, 1, 8)
-    const inspected = await inspectSymbol(g, {
-        ...args,
-        max_containers: Math.min(maxRelated, boundedInteger(args.max_containers, 10, 1, 30)),
-        context_lines: boundedInteger(args.context_lines, 4, 0, 12),
-    }, ctx)
-    const inspection = inspected?.result
-    if (!inspection || inspection.status !== 'OK') return inspected
-    const definition = {
-        ...inspection.definition,
-        name: String(g.byId.get(inspection.definition.id)?.label || '').replace(/\(\)$/, ''),
-    }
-    const classifier = createPathClassifier(ctx.repoRoot || null)
-    const includeClassified = args.include_classified === true
-    const inbound = aggregateEdges(g, g.inn.get(definition.id), maxRelated, {
-        classifier, includeClassified, productionFirst: true,
-    })
-    const outbound = aggregateEdges(g, g.out.get(definition.id), maxRelated, {callsiteFile: definition.file})
-    const reExports = exactReExportSites(g, definition, maxReExports)
-    const source = []
-    const overlaps = (left, right) => left.file === right.file
-        && left.startLine <= right.endLine && right.startLine <= left.endLine
-    const append = (role, excerpt) => {
-        if (!excerpt || source.length >= maxSourceFiles) return
-        if (source.some((item) => overlaps(item, excerpt))) return
-        source.push({role, ...excerpt})
-    }
-    append('Definition', inspection.source.definition)
-    const contextLines = boundedInteger(args.context_lines, 4, 0, 12)
-    const excerptCandidates = []
-    const groupExcerpts = (groups, role) => {
-        const primary = []
-        const secondary = []
-        for (const group of groups.shown) for (let index = 0; index < group.lines.length; index++) {
-            const candidate = {role, excerpt: sourceExcerpt(ctx.repoRoot, group.file, group.lines[index], contextLines)}
-            ;(index === 0 ? primary : secondary).push(candidate)
-        }
-        return [...primary, ...secondary]
-    }
-    const outboundExcerpts = groupExcerpts(outbound, 'Outbound call site')
-    const inboundExcerpts = groupExcerpts(inbound, 'Inbound call site')
-    for (let index = 0; index < Math.max(outboundExcerpts.length, inboundExcerpts.length); index++) {
-        if (outboundExcerpts[index]) excerptCandidates.push(outboundExcerpts[index])
-        if (inboundExcerpts[index]) excerptCandidates.push(inboundExcerpts[index])
-    }
-    for (const excerpt of inspection.source.callers || []) excerptCandidates.push({role: 'Reference', excerpt})
-    const deferred = []
-    for (const candidate of excerptCandidates) {
-        const knownFile = source.some((item) => item.file === candidate.excerpt?.file)
-        if (knownFile && candidate.role !== 'Outbound call site') deferred.push(candidate)
-        else append(candidate.role, candidate.excerpt)
-    }
-    for (const candidate of deferred) append(candidate.role, candidate.excerpt)
-    const result = {
-        status: 'OK', definition, evidence: inspection.evidence,
-        references: {
-            occurrences: inspection.exact.occurrences,
-            files: inspection.exact.files,
-            containers: inspection.exact.containers,
-            capped: inspection.exact.capped,
-        },
-        inbound, outbound, reExports, source,
-    }
-    return toolResult(textFor(result), result, {
-        warnings: inspected.warnings,
-        completeness: {
-            status: inspection.evidence.state === 'EXACT' && !inspection.exact.capped && !inbound.capped && !outbound.capped && !reExports.capped ? 'complete' : 'bounded',
-            relatedLimit: maxRelated,
-            reExportLimit: maxReExports,
-            sourceFileLimit: maxSourceFiles,
-        },
-    })
-}