weavatrix 0.3.12 → 0.3.14

package/src/mcp/tools-company.mjs

@@ -1,17 +1,16 @@
 // 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 {join} from 'node:path'
 import {analyzeHttpContracts} from '../analysis/http-contracts.js'
 import {analyzeTransportContracts} from '../analysis/transport-contracts.js'
-import {buildGraphForRepo} from '../build-graph.js'
 import {graphHomeDir} from '../graph/layout.js'
 import {liveRepositoryRecords} from '../graph/repo-registry.js'
-import {loadGraph} from './graph-context.mjs'
+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 = 3
+const CROSS_REPO_HTTP_CONTRACT_V = 4
 const selectorText = (value) => String(value ?? '').trim()
 
 function selectRecord(records, selector) {
@@ -35,76 +34,6 @@ function safeAlias(record, records) {
     return duplicates.length > 1 ? `${base}-${String(record.repositoryId).slice(0, 8)}` : base
 }
 
-function publicRecord(record, alias) {
-    return {repositoryId: record.repositoryId, label: record.label, alias}
-}
-
-function safeRefreshReason(record, error) {
-    let message = String(error instanceof Error ? error.message : error || 'graph refresh failed')
-    for (const path of [record.repoPath, record.graphDir]) {
-        if (!path) continue
-        message = message.split(String(path)).join(record.label || 'repository')
-        message = message.split(String(path).replace(/\\/g, '/')).join(record.label || 'repository')
-    }
-    return message.replace(/[\r\n]+/g, ' ').trim().slice(0, 400) || 'graph refresh failed'
-}
-
-async function reconcileGraph(record, alias, role, graphHome) {
-    let registeredGraph = null
-    try { registeredGraph = loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}) } catch { /* refresh may repair it */ }
-    const buildMode = ['full', 'no-tests', 'tests-only'].includes(registeredGraph?.graphBuildMode)
-        ? registeredGraph.graphBuildMode
-        : 'full'
-    const precision = registeredGraph?.graphPrecisionMode === 'off' ? 'off' : 'lsp'
-    let build
-    try {
-        build = await buildGraphForRepo(record.repoPath, {
-            mode: buildMode,
-            precision,
-            scope: '',
-            outDir: record.graphDir,
-            graphHome,
-        })
-    } catch (error) {
-        build = {ok: false, error: safeRefreshReason(record, error)}
-    }
-    const refreshKind = build?.refresh?.kind || null
-    const changedFiles = Array.isArray(build?.refresh?.changedFiles) ? build.refresh.changedFiles : []
-    const publicStatus = {
-        role,
-        repository: publicRecord(record, alias),
-        buildMode,
-        status: build?.ok ? (refreshKind === 'none' ? 'CURRENT' : 'REFRESHED') : 'STALE_FALLBACK',
-        refresh: build?.ok ? {
-            kind: refreshKind || 'full',
-            reason: String(build?.refresh?.reason || 'graph-rebuilt'),
-            changedFileCount: changedFiles.length,
-        } : null,
-    }
-    if (build?.ok) {
-        try {
-            return {record, alias, graph: loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}), publicStatus}
-        } catch (error) {
-            const reason = `refreshed graph could not be loaded: ${safeRefreshReason(record, error)}`
-            return {record, alias, graph: null, reason, publicStatus: {...publicStatus, status: 'FAILED', reason}}
-        }
-    }
-
-    const reason = `graph refresh failed: ${safeRefreshReason(record, build?.error)}`
-    try {
-        return {
-            record,
-            alias,
-            graph: loadGraph(join(record.graphDir, 'graph.json'), {repoRoot: record.repoPath}),
-            reason: `${reason}; stale registered graph used`,
-            publicStatus: {...publicStatus, reason: `${reason}; stale registered graph used`},
-        }
-    } catch (error) {
-        const loadReason = `${reason}; registered graph could not be loaded: ${safeRefreshReason(record, error)}`
-        return {record, alias, graph: null, reason: loadReason, publicStatus: {...publicStatus, status: 'FAILED', reason: loadReason}}
-    }
-}
-
 export async function tTraceApiContract(_g, args = {}, ctx = {}) {
     const graphHome = ctx.graphHome || graphHomeDir()
     const records = liveRepositoryRecords(graphHome)
@@ -246,6 +175,39 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
                 ? '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,
@@ -253,14 +215,28 @@ export async function tTraceApiContract(_g, args = {}, ctx = {}) {
                 backend: publicRecord(backend, backendAlias),
                 clients: clients.map(({record, alias}) => publicRecord(record, alias)),
             },
-            ...analysis,
-            transportContracts: transportAnalysis,
+            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) {

package/src/mcp/tools-context.mjs

@@ -6,7 +6,7 @@ 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 CONTEXT_NON_PRODUCT = Object.freeze(['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 
 const fileOf = (g, id) => {
     const node = g.byId.get(String(id))

package/src/mcp/tools-endpoints.mjs

@@ -4,7 +4,7 @@ import {createPathClassifier, hasPathClass} from '../path-classification.js'
 import {sourceExcerpt} from './tools-source.mjs'
 import {toolResult} from './tool-result.mjs'
 
-const NON_PRODUCT = ['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp']
+const NON_PRODUCT = ['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp']
 
 const symbolLine = (node) => Number(String(node?.source_location || '').match(/L(\d+)/)?.[1]
     || String(node?.id || '').match(/@(\d+)$/)?.[1] || 0)

package/src/mcp/tools-graph-hubs.mjs

@@ -3,7 +3,7 @@ import {connList} from './graph-context.mjs'
 import {createPathClassifier, hasPathClass} from '../path-classification.js'
 
 const isCompileTimeEdge = (edge) => edge?.typeOnly === true || edge?.compileOnly === true
-const NON_PRODUCT_CLASSES = Object.freeze(['test', 'e2e', 'generated', 'mock', 'story', 'docs', 'benchmark', 'temp'])
+const NON_PRODUCT_CLASSES = Object.freeze(['test', 'e2e', 'generated', 'vendored', 'mock', 'story', 'docs', 'benchmark', 'temp'])
 const sourceFileOf = (node) => String(node?.source_file || (node?.file_type === 'code' ? node?.id : '') || '').replace(/\\/g, '/')
 
 export function tGodNodes(g, {top_n = 10, include_classified = false} = {}, ctx = {}) {

package/src/mcp/tools-verified-change.mjs

@@ -148,10 +148,17 @@ export async function tVerifiedChange(g, args = {}, ctx = {}, tools = {}, permis
   const baseRef = String(args.base_ref || 'HEAD').trim()
   const graph = phase === 'verify' ? await baselineProof(ctx, baseRef, currentGraph) : {state: 'PLANNED', baseline: baseRef}
 
-  let duplicates = {state: 'SKIPPED', reason: 'duplicate ratchet disabled'}
-  if (phase === 'verify' && args.duplicate_ratchet !== false) duplicates = permissions.health
-    ? await compareDuplicateGroups({repoRoot: ctx.repoRoot, graphPath: ctx.graphPath, currentGraph, baseRef, changedFiles, args: {mode: 'renamed', min_similarity: 80, min_tokens: 50}})
-    : {state: 'UNKNOWN', reason: 'health capability is not enabled'}
+  const duplicateRatchetEnabled = args.duplicate_ratchet !== false
+  let duplicates
+  if (!duplicateRatchetEnabled) {
+    duplicates = {state: 'SKIPPED', enabled: false, reason: 'duplicate ratchet disabled'}
+  } else if (phase !== 'verify') {
+    duplicates = {state: 'PLANNED', enabled: true, reason: 'duplicate ratchet runs during verify phase'}
+  } else {
+    duplicates = permissions.health
+      ? {enabled: true, ...await compareDuplicateGroups({repoRoot: ctx.repoRoot, graphPath: ctx.graphPath, currentGraph, baseRef, changedFiles, args: {mode: 'renamed', min_similarity: 80, min_tokens: 50}})}
+      : {state: 'UNKNOWN', enabled: true, reason: 'health capability is not enabled'}
+  }
 
   let api = {state: 'SKIPPED', reason: 'no api_contract scope was requested'}
   if (args.api_contract) {

package/src/path-classification.js

@@ -4,11 +4,12 @@
 import { openSync, closeSync, readSync, readFileSync, statSync } from "node:fs";
 import { createRepoBoundary } from "./repo-path.js";
 
-export const PATH_CLASS_NAMES = Object.freeze(["test", "e2e", "generated", "mock", "story", "docs", "benchmark", "temp"]);
+export const PATH_CLASS_NAMES = Object.freeze(["test", "e2e", "generated", "vendored", "mock", "story", "docs", "benchmark", "temp"]);
 export const PATH_CLASS_QUERY_TERMS = Object.freeze({
   test: Object.freeze(["test", "tests", "testing", "unit"]),
   e2e: Object.freeze(["e2e", "playwright", "cypress"]),
   generated: Object.freeze(["generated", "autogenerated", "dist"]),
+  vendored: Object.freeze(["vendor", "vendored", "third-party", "third_party"]),
   mock: Object.freeze(["mock", "mocks", "fixture", "fixtures", "fake"]),
   story: Object.freeze(["story", "stories", "storybook"]),
   docs: Object.freeze(["doc", "docs", "documentation", "readme", "guide"]),
@@ -72,6 +73,11 @@ const DEFAULT_RULES = [
     pattern: "conventional build output path",
     regex: /(^|\/)(?:dist|build|out|coverage|\.next)(\/|$)/i,
   },
+  {
+    category: "vendored",
+    pattern: "vendored or third-party source root",
+    regex: /(^|\/)(?:vendor|vendored|third[-_]?party)(\/|$)/i,
+  },
   {
     category: "mock",
     pattern: "mock/fixture path or mockData filename",