trace-mcp 1.9.0 → 1.10.0

package/dist/index.js

@@ -3650,7 +3650,7 @@ function captureGraphSnapshots(store, cwd) {
 
 // src/db/schema.ts
 import Database from "better-sqlite3";
-var SCHEMA_VERSION = 17;
+var SCHEMA_VERSION = 18;
 var DDL = `
 -- ============================================================
 -- UNIFIED ADDRESS SPACE
@@ -4830,57 +4830,41 @@ var FilePersister = class {
     if (ext.gitignored) {
       store.updateFileGitignored(fileId, true);
     }
-    if (ext.symbols.length > 0) {
-      const insertedIds = store.insertSymbols(fileId, ext.symbols);
-      const trigramBySymbolId = /* @__PURE__ */ new Map();
-      for (let i = 0; i < ext.symbols.length; i++) {
-        trigramBySymbolId.set(ext.symbols[i].symbolId, {
-          id: insertedIds[i],
-          name: ext.symbols[i].name,
-          fqn: ext.symbols[i].fqn ?? null
-        });
-      }
-      indexTrigramsBatch(store.db, [...trigramBySymbolId.values()]);
-    }
-    if (ext.otherEdges.length > 0) this.storeRawEdges(ext.otherEdges);
+    this.persistSymbolsAndEntities(fileId, ext.symbols, ext.otherEdges, ext);
     if (ext.importEdges.length > 0) {
       this.state.pendingImports.set(fileId, ext.importEdges);
     }
-    for (const r of ext.routes) store.insertRoute(r, fileId);
-    for (const c of ext.components) store.insertComponent(c, fileId);
-    for (const m of ext.migrations) store.insertMigration(m, fileId);
-    if (ext.ormModels.length > 0) {
-      this.storeOrmResults(ext.ormModels, ext.ormAssociations, fileId);
-    }
-    for (const s of ext.rnScreens) store.insertRnScreen(s, fileId);
     for (const fwResult of ext.frameworkExtracts) {
-      if (fwResult.symbols.length > 0) {
-        const fwIds = store.insertSymbols(fileId, fwResult.symbols);
-        const fwTrigramBySymbolId = /* @__PURE__ */ new Map();
-        for (let i = 0; i < fwResult.symbols.length; i++) {
-          fwTrigramBySymbolId.set(fwResult.symbols[i].symbolId, {
-            id: fwIds[i],
-            name: fwResult.symbols[i].name,
-            fqn: fwResult.symbols[i].fqn ?? null
-          });
-        }
-        indexTrigramsBatch(store.db, [...fwTrigramBySymbolId.values()]);
-      }
-      if (fwResult.edges?.length) {
-        this.storeRawEdges(fwResult.edges);
-      }
-      for (const r of fwResult.routes ?? []) store.insertRoute(r, fileId);
-      for (const c of fwResult.components ?? []) store.insertComponent(c, fileId);
-      for (const m of fwResult.migrations ?? []) store.insertMigration(m, fileId);
-      if (fwResult.ormModels?.length) {
-        this.storeOrmResults(fwResult.ormModels, fwResult.ormAssociations ?? [], fileId);
-      }
-      for (const s of fwResult.rnScreens ?? []) store.insertRnScreen(s, fileId);
+      this.persistSymbolsAndEntities(fileId, fwResult.symbols, fwResult.edges ?? [], fwResult);
       if (fwResult.frameworkRole) {
         store.updateFileStatus(fileId, fwResult.status, fwResult.frameworkRole);
       }
     }
   }
+  /** Insert symbols+trigrams, edges, and entities (routes/components/migrations/ORM/screens). */
+  persistSymbolsAndEntities(fileId, symbols, edges, entities) {
+    const store = this.state.store;
+    if (symbols.length > 0) {
+      const insertedIds = store.insertSymbols(fileId, symbols);
+      const trigramBySymbolId = /* @__PURE__ */ new Map();
+      for (let i = 0; i < symbols.length; i++) {
+        trigramBySymbolId.set(symbols[i].symbolId, {
+          id: insertedIds[i],
+          name: symbols[i].name,
+          fqn: symbols[i].fqn ?? null
+        });
+      }
+      indexTrigramsBatch(store.db, [...trigramBySymbolId.values()]);
+    }
+    if (edges.length > 0) this.storeRawEdges(edges);
+    for (const r of entities.routes ?? []) store.insertRoute(r, fileId);
+    for (const c of entities.components ?? []) store.insertComponent(c, fileId);
+    for (const m of entities.migrations ?? []) store.insertMigration(m, fileId);
+    if (entities.ormModels?.length) {
+      this.storeOrmResults(entities.ormModels, entities.ormAssociations ?? [], fileId);
+    }
+    for (const s of entities.rnScreens ?? []) store.insertRnScreen(s, fileId);
+  }
   /**
    * Fast path for incremental re-indexing: if the set of symbols is structurally
    * identical (same symbolIds, names, kinds, fqns, signatures), only update byte
@@ -6040,58 +6024,10 @@ var IndexingPipeline = class _IndexingPipeline {
     this._gitignore = new GitignoreMatcher(this.rootPath);
     this._traceignore = new TraceignoreMatcher(this.rootPath, this.config.ignore);
     this.registerFrameworkEdgeTypes();
-    const extractor = new FileExtractor({
-      store: this.store,
-      registry: this.registry,
-      rootPath: this.rootPath,
-      workspaces: this.workspaces,
-      gitignore: this._gitignore,
-      fileContentCache: this._fileContentCache,
-      buildProjectContext: () => this.buildProjectContext()
-    });
     try {
-      disableFts5Triggers(this.store.db);
-      const BATCH_SIZE3 = Math.min(500, Math.max(100, Math.ceil(relPaths.length / 20)));
-      const CONCURRENCY = Math.min(8, cpus().length);
-      for (let i = 0; i < relPaths.length; i += BATCH_SIZE3) {
-        const batch = relPaths.slice(i, i + BATCH_SIZE3);
-        const extractions = [];
-        for (let c = 0; c < batch.length; c += CONCURRENCY) {
-          const chunk = batch.slice(c, c + CONCURRENCY);
-          const results = await Promise.all(
-            chunk.map((relPath) => extractor.extract(relPath, force))
-          );
-          for (const ext of results) {
-            if (ext === "skipped") {
-              result.skipped++;
-              continue;
-            }
-            if (ext === "error") {
-              result.errors++;
-              continue;
-            }
-            extractions.push(ext);
-          }
-        }
-        if (extractions.length > 0) {
-          const state = this.getPipelineState();
-          const persistEdgeResolver = new EdgeResolver(state);
-          const persister = new FilePersister(state, (edges) => persistEdgeResolver.storeRawEdges(edges));
-          persister.persistBatch(extractions);
-          result.indexed += extractions.length;
-        }
-        const processed = result.indexed + result.skipped + result.errors;
-        this.progress?.update("indexing", { processed });
-      }
-      enableFts5Triggers(this.store.db);
-      const edgeResolver = new EdgeResolver(this.getPipelineState());
-      await edgeResolver.resolveEdges(this.buildProjectContext(), this.buildResolveContext());
-      edgeResolver.resolveOrmAssociationEdges();
-      edgeResolver.resolveTypeScriptHeritageEdges();
-      edgeResolver.resolveEsmImportEdges();
-      edgeResolver.resolveTestCoversEdges();
-      const envIndexer = new EnvIndexer(this.store, this.config, this.rootPath, this._traceignore);
-      await envIndexer.indexEnvFiles(force);
+      await this.extractAndPersist(relPaths, force, result);
+      await this.resolveAllEdges();
+      await this.indexEnvFiles(force);
     } finally {
       this._fileContentCache.clear();
       this._pendingImports.clear();
@@ -6115,6 +6051,66 @@ var IndexingPipeline = class _IndexingPipeline {
     logger.info(result, "Indexing pipeline completed");
     return result;
   }
+  /** Pass 1: extract symbols from files and persist in batched transactions. */
+  async extractAndPersist(relPaths, force, result) {
+    const extractor = new FileExtractor({
+      store: this.store,
+      registry: this.registry,
+      rootPath: this.rootPath,
+      workspaces: this.workspaces,
+      gitignore: this._gitignore,
+      fileContentCache: this._fileContentCache,
+      buildProjectContext: () => this.buildProjectContext()
+    });
+    disableFts5Triggers(this.store.db);
+    const BATCH_SIZE3 = Math.min(500, Math.max(100, Math.ceil(relPaths.length / 20)));
+    const CONCURRENCY = Math.min(8, cpus().length);
+    for (let i = 0; i < relPaths.length; i += BATCH_SIZE3) {
+      const batch = relPaths.slice(i, i + BATCH_SIZE3);
+      const extractions = [];
+      for (let c = 0; c < batch.length; c += CONCURRENCY) {
+        const chunk = batch.slice(c, c + CONCURRENCY);
+        const results = await Promise.all(
+          chunk.map((relPath) => extractor.extract(relPath, force))
+        );
+        for (const ext of results) {
+          if (ext === "skipped") {
+            result.skipped++;
+            continue;
+          }
+          if (ext === "error") {
+            result.errors++;
+            continue;
+          }
+          extractions.push(ext);
+        }
+      }
+      if (extractions.length > 0) {
+        const state = this.getPipelineState();
+        const persistEdgeResolver = new EdgeResolver(state);
+        const persister = new FilePersister(state, (edges) => persistEdgeResolver.storeRawEdges(edges));
+        persister.persistBatch(extractions);
+        result.indexed += extractions.length;
+      }
+      const processed = result.indexed + result.skipped + result.errors;
+      this.progress?.update("indexing", { processed });
+    }
+    enableFts5Triggers(this.store.db);
+  }
+  /** Pass 2: resolve all edge types (imports, heritage, ORM, tests). */
+  async resolveAllEdges() {
+    const edgeResolver = new EdgeResolver(this.getPipelineState());
+    await edgeResolver.resolveEdges(this.buildProjectContext(), this.buildResolveContext());
+    edgeResolver.resolveOrmAssociationEdges();
+    edgeResolver.resolveTypeScriptHeritageEdges();
+    edgeResolver.resolveEsmImportEdges();
+    edgeResolver.resolveTestCoversEdges();
+  }
+  /** Pass 3: index .env files for environment variable tracking. */
+  async indexEnvFiles(force) {
+    const envIndexer = new EnvIndexer(this.store, this.config, this.rootPath, this._traceignore);
+    await envIndexer.indexEnvFiles(force);
+  }
   buildProjectContext() {
     if (!this._projectContext) {
       this._projectContext = buildProjectContext(this.rootPath);
@@ -8589,186 +8585,6 @@ function getProjectMap(store, registry, summaryOnly, projectContext) {
 }
 
 // src/tools/analysis/duplication.ts
-var CHECKABLE_KINDS = /* @__PURE__ */ new Set([
-  "function",
-  "class",
-  "method",
-  "interface",
-  "type_alias",
-  "enum"
-]);
-var TRIVIAL_NAMES = /* @__PURE__ */ new Set([
-  "constructor",
-  "toString",
-  "toJSON",
-  "valueOf",
-  "render",
-  "setup",
-  "main",
-  "index",
-  "default",
-  "init",
-  "create",
-  "get",
-  "set",
-  "delete",
-  "update",
-  "handle",
-  "process",
-  "run",
-  "start",
-  "stop",
-  "reset",
-  "configure",
-  "register",
-  "execute",
-  "validate",
-  "transform",
-  "apply",
-  "call",
-  "bind",
-  "map",
-  "filter",
-  "reduce",
-  "forEach",
-  "connect",
-  "disconnect",
-  "open",
-  "close",
-  "build",
-  "destroy",
-  "mount",
-  "unmount",
-  "dispose",
-  "serialize",
-  "deserialize"
-]);
-var TEST_PATH_RE2 = /(?:^|[/\\])(?:tests?|__tests__|spec)[/\\]|\.(?:test|spec)\.[jt]sx?$/i;
-var MIN_NAME_LENGTH = 4;
-var MAX_SYMBOLS_PER_FILE2 = 30;
-var W_NAME = 0.45;
-var W_KIND = 0.15;
-var W_SIGNATURE = 0.25;
-var W_TOKEN = 0.15;
-function tokenizeName(name) {
-  const parts = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().split(/[_\-./:]+/).filter((p) => p.length > 1);
-  return new Set(parts);
-}
-function jaccard(a, b) {
-  if (a.size === 0 && b.size === 0) return 0;
-  let intersection = 0;
-  for (const t of a) {
-    if (b.has(t)) intersection++;
-  }
-  const union = a.size + b.size - intersection;
-  return union === 0 ? 0 : intersection / union;
-}
-function signatureSimilarity(srcParamCount, candParamCount) {
-  if (srcParamCount == null && candParamCount == null) return 0.5;
-  if (srcParamCount == null || candParamCount == null) return 0.3;
-  const max = Math.max(srcParamCount, candParamCount, 1);
-  return 1 - Math.abs(srcParamCount - candParamCount) / max;
-}
-function getHeritageNames(metadata) {
-  if (!metadata) return /* @__PURE__ */ new Set();
-  try {
-    const parsed = JSON.parse(metadata);
-    const names = /* @__PURE__ */ new Set();
-    if (typeof parsed.extends === "string") names.add(parsed.extends);
-    if (Array.isArray(parsed.extends)) {
-      for (const e of parsed.extends) if (typeof e === "string") names.add(e);
-    }
-    if (typeof parsed.implements === "string") names.add(parsed.implements);
-    if (Array.isArray(parsed.implements)) {
-      for (const i of parsed.implements) if (typeof i === "string") names.add(i);
-    }
-    return names;
-  } catch {
-    return /* @__PURE__ */ new Set();
-  }
-}
-function findDuplicateSymbols(store, db, sourceSymbols, sourceFileId, sourceFilePath, options) {
-  const threshold = options?.threshold ?? 0.7;
-  const maxResults = options?.maxResults ?? 10;
-  const sourceIsTest = TEST_PATH_RE2.test(sourceFilePath);
-  const heritageNames = /* @__PURE__ */ new Set();
-  for (const sym of sourceSymbols) {
-    const h = getHeritageNames(sym.metadata);
-    for (const n of h) heritageNames.add(n);
-  }
-  const checkable = sourceSymbols.filter(
-    (s) => CHECKABLE_KINDS.has(s.kind) && s.name.length >= MIN_NAME_LENGTH && !TRIVIAL_NAMES.has(s.name)
-  ).slice(0, MAX_SYMBOLS_PER_FILE2);
-  const allWarnings = [];
-  const paramCountStmt = db.prepare(
-    "SELECT param_count FROM symbols WHERE id = ?"
-  );
-  for (const src of checkable) {
-    const srcParamCount = src.param_count ?? paramCountStmt.get(src.id)?.param_count ?? null;
-    const srcTokens = tokenizeName(src.fqn ?? src.name);
-    const candidates = fuzzySearch(db, src.name, {
-      threshold: 0.25,
-      limit: 30,
-      kind: src.kind
-    });
-    for (const cand of candidates) {
-      if (cand.fileId === sourceFileId) continue;
-      if (cand.symbolIdStr === src.symbol_id) continue;
-      const candFile = store.getFileById(cand.fileId);
-      if (!candFile) continue;
-      const candIsTest = TEST_PATH_RE2.test(candFile.path);
-      if (sourceIsTest !== candIsTest) continue;
-      if (heritageNames.has(cand.name)) continue;
-      const candSymbol = getCandidateSymbol(db, cand.symbolId);
-      if (candSymbol) {
-        const candHeritage = getHeritageNames(candSymbol.metadata);
-        for (const h of candHeritage) {
-          if (heritageNames.has(h)) continue;
-        }
-      }
-      const nameSim = cand.similarity;
-      const kindMatch = cand.kind === src.kind ? 1 : 0;
-      const candParamCount = candSymbol?.param_count ?? paramCountStmt.get(cand.symbolId)?.param_count ?? null;
-      const sigSim = signatureSimilarity(srcParamCount, candParamCount);
-      const candTokens = tokenizeName(cand.fqn ?? cand.name);
-      const tokenOvl = jaccard(srcTokens, candTokens);
-      const score = W_NAME * nameSim + W_KIND * kindMatch + W_SIGNATURE * sigSim + W_TOKEN * tokenOvl;
-      if (score >= threshold) {
-        allWarnings.push({
-          source_symbol_id: src.symbol_id,
-          source_name: src.name,
-          source_file: sourceFilePath,
-          duplicate_symbol_id: cand.symbolIdStr,
-          duplicate_name: cand.name,
-          duplicate_file: candFile.path,
-          duplicate_line: candSymbol?.line_start ?? null,
-          score: Math.round(score * 1e3) / 1e3,
-          signals: {
-            name_similarity: Math.round(nameSim * 1e3) / 1e3,
-            kind_match: kindMatch,
-            signature_similarity: Math.round(sigSim * 1e3) / 1e3,
-            token_overlap: Math.round(tokenOvl * 1e3) / 1e3
-          }
-        });
-      }
-    }
-  }
-  allWarnings.sort((a, b) => b.score - a.score);
-  const seen = /* @__PURE__ */ new Set();
-  const deduped = [];
-  for (const w of allWarnings) {
-    const key = `${w.source_symbol_id}::${w.duplicate_symbol_id}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    deduped.push(w);
-    if (deduped.length >= maxResults) break;
-  }
-  return {
-    warnings: deduped,
-    symbols_checked: checkable.length,
-    threshold
-  };
-}
 function checkFileForDuplicates(store, db, filePath, options) {
   const file = store.getFile(filePath);
   if (!file) {
@@ -8811,11 +8627,6 @@ function checkSymbolForDuplicates(store, db, query, options) {
   }
   return { warnings: [], symbols_checked: 0, threshold };
 }
-function getCandidateSymbol(db, symbolId) {
-  return db.prepare(
-    "SELECT * FROM symbols WHERE id = ?"
-  ).get(symbolId);
-}
 
 // src/tools/register/core.ts
 function registerCoreTools(server, ctx) {
@@ -10657,11 +10468,11 @@ function suggestQueries(store) {
 
 // src/tools/navigation/related.ts
 import { ok as ok4, err as err5 } from "neverthrow";
-function tokenizeName2(name) {
+function tokenizeName(name) {
   const parts = name.replace(/([a-z])([A-Z])/g, "$1_$2").toLowerCase().split(/[_\-.]/).filter((p) => p.length > 1);
   return new Set(parts);
 }
-function jaccard2(a, b) {
+function jaccard(a, b) {
   if (a.size === 0 && b.size === 0) return 0;
   let intersection = 0;
   for (const t of a) {
@@ -10750,13 +10561,13 @@ function getRelatedSymbols(store, opts) {
       }
     }
   }
-  const targetTokens = tokenizeName2(target.name);
+  const targetTokens = tokenizeName(target.name);
   const candidateIds = [...scores.keys()];
   const candidateSymbols = store.getSymbolsByIds(candidateIds);
   const candidateFileIds = [...new Set([...candidateSymbols.values()].map((s) => s.file_id))];
   const fileMap = store.getFilesByIds(candidateFileIds);
   for (const [symId, sym] of candidateSymbols) {
-    const nameScore = jaccard2(targetTokens, tokenizeName2(sym.name));
+    const nameScore = jaccard(targetTokens, tokenizeName(sym.name));
     if (nameScore > 0) {
       ensureEntry(symId).name_overlap = nameScore;
     }
@@ -11853,63 +11664,9 @@ var FederationManager = class {
         detectionSource: svc.detectionSource,
         metadata: svc.metadata
       });
-      const contracts = parseContracts(svc.repoRoot);
-      if (opts?.contractPaths) {
-        for (const cp of opts.contractPaths) {
-          const absContract = path29.resolve(absRoot, cp);
-          if (fs23.existsSync(absContract)) {
-            const additionalContracts = parseContracts(path29.dirname(absContract));
-            contracts.push(...additionalContracts.filter(
-              (c) => path29.resolve(absRoot, c.specPath) === absContract
-            ));
-          }
-        }
-      }
-      for (const contract of contracts) {
-        const contractId = this.topoStore.insertContract(serviceId, {
-          contractType: contract.type,
-          specPath: contract.specPath,
-          version: contract.version,
-          parsedSpec: JSON.stringify({ endpoints: contract.endpoints, events: contract.events })
-        });
-        this.topoStore.insertEndpoints(
-          contractId,
-          serviceId,
-          contract.endpoints.map((e) => ({
-            method: e.method ?? void 0,
-            path: e.path,
-            operationId: e.operationId,
-            requestSchema: e.requestSchema ? JSON.stringify(e.requestSchema) : void 0,
-            responseSchema: e.responseSchema ? JSON.stringify(e.responseSchema) : void 0
-          }))
-        );
-        if (contract.events.length > 0) {
-          this.topoStore.insertEventChannels(
-            contractId,
-            serviceId,
-            contract.events.map((e) => ({
-              channelName: e.channelName,
-              direction: e.direction
-            }))
-          );
-        }
-      }
+      this.registerContracts(serviceId, svc.repoRoot, absRoot, opts?.contractPaths);
     }
-    this.topoStore.deleteClientCallsByRepo(repoId);
-    const clientCalls = scanClientCalls(absRoot);
-    if (clientCalls.length > 0) {
-      this.topoStore.insertClientCalls(clientCalls.map((c) => ({
-        sourceRepoId: repoId,
-        filePath: c.filePath,
-        line: c.line,
-        callType: c.callType,
-        method: c.method,
-        urlPattern: c.urlPattern,
-        confidence: c.confidence
-      })));
-    }
-    const linkedCount = this.topoStore.linkClientCallsToEndpoints();
-    this.buildCrossServiceEdges();
+    const clientCalls = this.scanAndLinkClientCalls(repoId, absRoot);
     this.topoStore.updateFederatedRepoSyncTime(repoId);
     const stats = this.topoStore.getTopologyStats();
     return {
@@ -11918,8 +11675,8 @@ var FederationManager = class {
       services: detected.length,
       contracts: stats.contracts,
       endpoints: stats.endpoints,
-      clientCalls: clientCalls.length,
-      linkedCalls: linkedCount
+      clientCalls: clientCalls.scanned,
+      linkedCalls: clientCalls.linked
     };
   }
   /**
@@ -12023,75 +11780,26 @@ var FederationManager = class {
           detectionSource: svc.detectionSource,
           metadata: svc.metadata
         });
-        const existingContracts = this.topoStore.getContractsByService(serviceId);
-        for (const ec of existingContracts) {
-          this.topoStore.insertContractSnapshot(ec.id, serviceId, {
-            version: ec.version,
-            specPath: ec.spec_path,
-            contentHash: ec.content_hash ?? "",
-            endpointsJson: ec.parsed_spec,
-            eventsJson: "[]"
-          });
-        }
+        this.snapshotContracts(serviceId);
         this.topoStore.deleteContractsByService(serviceId);
         const contracts = parseContracts(svc.repoRoot);
         contractsUpdated += contracts.length;
         for (const contract of contracts) {
-          const contractId = this.topoStore.insertContract(serviceId, {
-            contractType: contract.type,
-            specPath: contract.specPath,
-            version: contract.version,
-            parsedSpec: JSON.stringify({ endpoints: contract.endpoints, events: contract.events })
-          });
-          this.topoStore.insertEndpoints(
-            contractId,
-            serviceId,
-            contract.endpoints.map((e) => ({
-              method: e.method ?? void 0,
-              path: e.path,
-              operationId: e.operationId,
-              requestSchema: e.requestSchema ? JSON.stringify(e.requestSchema) : void 0,
-              responseSchema: e.responseSchema ? JSON.stringify(e.responseSchema) : void 0
-            }))
-          );
           endpointsUpdated += contract.endpoints.length;
-          if (contract.events.length > 0) {
-            this.topoStore.insertEventChannels(
-              contractId,
-              serviceId,
-              contract.events.map((e) => ({
-                channelName: e.channelName,
-                direction: e.direction
-              }))
-            );
-          }
         }
+        this.registerContracts(serviceId, svc.repoRoot);
       }
-      this.topoStore.deleteClientCallsByRepo(repo.id);
-      const calls = scanClientCalls(repo.repo_root);
-      clientCallsScanned += calls.length;
-      if (calls.length > 0) {
-        this.topoStore.insertClientCalls(calls.map((c) => ({
-          sourceRepoId: repo.id,
-          filePath: c.filePath,
-          line: c.line,
-          callType: c.callType,
-          method: c.method,
-          urlPattern: c.urlPattern,
-          confidence: c.confidence
-        })));
-      }
+      const calls = this.scanAndLinkClientCalls(repo.id, repo.repo_root);
+      clientCallsScanned += calls.scanned;
       this.topoStore.updateFederatedRepoSyncTime(repo.id);
     }
-    const newlyLinked = this.topoStore.linkClientCallsToEndpoints();
-    this.buildCrossServiceEdges();
     return {
       repos: repos.length,
       servicesUpdated,
       contractsUpdated,
       endpointsUpdated,
       clientCallsScanned,
-      newlyLinked,
+      newlyLinked: this.topoStore.linkClientCallsToEndpoints(),
       crossRepoEdges: this.topoStore.getTopologyStats().crossEdges
     };
   }
@@ -12101,82 +11809,18 @@ var FederationManager = class {
    * If per-repo DBs exist, resolves down to symbol level.
    */
   getImpact(opts) {
+    const matchingEndpoints = this.filterEndpoints(opts);
     const results = [];
-    const allEndpoints = this.topoStore.getAllEndpoints();
-    let matchingEndpoints = allEndpoints;
-    if (opts.endpoint) {
-      const normalized = opts.endpoint.toLowerCase();
-      matchingEndpoints = allEndpoints.filter(
-        (ep) => ep.path.toLowerCase().includes(normalized)
-      );
-    }
-    if (opts.method) {
-      matchingEndpoints = matchingEndpoints.filter(
-        (ep) => ep.method?.toUpperCase() === opts.method.toUpperCase()
-      );
-    }
-    if (opts.service) {
-      matchingEndpoints = matchingEndpoints.filter(
-        (ep) => ep.service_name.toLowerCase() === opts.service.toLowerCase()
-      );
-    }
     for (const ep of matchingEndpoints) {
       const clientCalls = this.topoStore.getClientCallsByEndpoint(ep.id);
       if (clientCalls.length === 0) continue;
-      const byRepo = /* @__PURE__ */ new Map();
-      for (const call of clientCalls) {
-        const repo2 = call.source_repo_name;
-        if (!byRepo.has(repo2)) byRepo.set(repo2, []);
-        byRepo.get(repo2).push(call);
-      }
-      const clients = [];
-      for (const [repoName, calls] of byRepo) {
-        const repo2 = this.topoStore.getFederatedRepo(repoName);
-        for (const call of calls) {
-          const symbols = repo2?.db_path && fs23.existsSync(repo2.db_path) ? resolveSymbolsAtLocation(repo2.db_path, call.file_path, call.line) : [];
-          clients.push({
-            repo: repoName,
-            filePath: call.file_path,
-            line: call.line,
-            callType: call.call_type,
-            confidence: call.confidence,
-            symbols
-          });
-        }
-      }
+      const clients = this.collectEndpointClients(clientCalls);
       const uniqueRepos = new Set(clients.map((c) => c.repo));
-      const riskLevel3 = uniqueRepos.size >= 3 ? "critical" : uniqueRepos.size >= 2 ? "high" : clients.length >= 3 ? "medium" : "low";
+      const baseRisk = computeRiskLevel(uniqueRepos.size, clients.length);
       const svc = this.topoStore.getAllServices().find((s) => s.id === ep.service_id);
       const repo = svc ? this.topoStore.getFederatedRepo(svc.repo_root) : void 0;
-      let breakingChanges;
-      const contracts = this.topoStore.getContractsByService(ep.service_id);
-      for (const contract of contracts) {
-        const snapshot = this.topoStore.getLatestSnapshot(contract.id);
-        if (!snapshot) continue;
-        let oldEndpoints = [];
-        try {
-          const parsed = JSON.parse(snapshot.endpoints_json);
-          oldEndpoints = (parsed.endpoints ?? []).map((e) => ({ method: e.method ?? null, path: e.path, requestSchema: e.requestSchema, responseSchema: e.responseSchema }));
-        } catch {
-          continue;
-        }
-        const currentEndpoints = this.topoStore.getEndpointsByService(ep.service_id).map((e) => ({
-          method: e.method,
-          path: e.path,
-          requestSchema: e.request_schema,
-          responseSchema: e.response_schema
-        }));
-        const epDiffs = diffEndpoints(oldEndpoints, currentEndpoints).filter((d) => d.endpoint.path === ep.path && (d.endpoint.method ?? "*") === (ep.method ?? "*"));
-        if (epDiffs.length > 0 && epDiffs.some((d) => d.breaking)) {
-          breakingChanges = epDiffs;
-        }
-      }
-      let finalRiskLevel = riskLevel3;
-      if (breakingChanges?.some((d) => d.breaking)) {
-        const riskLevels = ["low", "medium", "high", "critical"];
-        const idx = riskLevels.indexOf(riskLevel3);
-        if (idx < riskLevels.length - 1) finalRiskLevel = riskLevels[idx + 1];
-      }
+      const breakingChanges = this.detectBreakingChanges(ep);
+      const riskLevel3 = upgradeRiskIfBreaking(baseRisk, breakingChanges);
       results.push({
         endpoint: {
           method: ep.method,
@@ -12185,13 +11829,152 @@ var FederationManager = class {
           repo: repo?.name ?? svc?.repo_root ?? "unknown"
         },
         clients,
-        riskLevel: finalRiskLevel,
+        riskLevel: riskLevel3,
         summary: `${ep.method ?? "*"} ${ep.path} is called by ${clients.length} client(s) in ${uniqueRepos.size} repo(s)${breakingChanges ? " \u26A0 BREAKING SCHEMA CHANGES" : ""}`,
         breakingChanges
       });
     }
     return results;
   }
+  /** Register contracts for a service, including explicitly provided paths. */
+  registerContracts(serviceId, serviceRoot, repoRoot, explicitPaths) {
+    const contracts = parseContracts(serviceRoot);
+    if (explicitPaths && repoRoot) {
+      for (const cp of explicitPaths) {
+        const absContract = path29.resolve(repoRoot, cp);
+        if (fs23.existsSync(absContract)) {
+          const additional = parseContracts(path29.dirname(absContract));
+          contracts.push(...additional.filter(
+            (c) => path29.resolve(repoRoot, c.specPath) === absContract
+          ));
+        }
+      }
+    }
+    for (const contract of contracts) {
+      const contractId = this.topoStore.insertContract(serviceId, {
+        contractType: contract.type,
+        specPath: contract.specPath,
+        version: contract.version,
+        parsedSpec: JSON.stringify({ endpoints: contract.endpoints, events: contract.events })
+      });
+      this.topoStore.insertEndpoints(
+        contractId,
+        serviceId,
+        contract.endpoints.map((e) => ({
+          method: e.method ?? void 0,
+          path: e.path,
+          operationId: e.operationId,
+          requestSchema: e.requestSchema ? JSON.stringify(e.requestSchema) : void 0,
+          responseSchema: e.responseSchema ? JSON.stringify(e.responseSchema) : void 0
+        }))
+      );
+      if (contract.events.length > 0) {
+        this.topoStore.insertEventChannels(
+          contractId,
+          serviceId,
+          contract.events.map((e) => ({
+            channelName: e.channelName,
+            direction: e.direction
+          }))
+        );
+      }
+    }
+  }
+  /** Snapshot existing contracts before replacing them (for drift detection). */
+  snapshotContracts(serviceId) {
+    const existing = this.topoStore.getContractsByService(serviceId);
+    for (const ec of existing) {
+      this.topoStore.insertContractSnapshot(ec.id, serviceId, {
+        version: ec.version,
+        specPath: ec.spec_path,
+        contentHash: ec.content_hash ?? "",
+        endpointsJson: ec.parsed_spec,
+        eventsJson: "[]"
+      });
+    }
+  }
+  /** Scan repo for client calls, insert them, link to endpoints, and build edges. */
+  scanAndLinkClientCalls(repoId, repoRoot) {
+    this.topoStore.deleteClientCallsByRepo(repoId);
+    const clientCalls = scanClientCalls(repoRoot);
+    if (clientCalls.length > 0) {
+      this.topoStore.insertClientCalls(clientCalls.map((c) => ({
+        sourceRepoId: repoId,
+        filePath: c.filePath,
+        line: c.line,
+        callType: c.callType,
+        method: c.method,
+        urlPattern: c.urlPattern,
+        confidence: c.confidence
+      })));
+    }
+    const linked = this.topoStore.linkClientCallsToEndpoints();
+    this.buildCrossServiceEdges();
+    return { scanned: clientCalls.length, linked };
+  }
+  filterEndpoints(opts) {
+    let endpoints = this.topoStore.getAllEndpoints();
+    if (opts.endpoint) {
+      const normalized = opts.endpoint.toLowerCase();
+      endpoints = endpoints.filter((ep) => ep.path.toLowerCase().includes(normalized));
+    }
+    if (opts.method) {
+      endpoints = endpoints.filter((ep) => ep.method?.toUpperCase() === opts.method.toUpperCase());
+    }
+    if (opts.service) {
+      endpoints = endpoints.filter((ep) => ep.service_name.toLowerCase() === opts.service.toLowerCase());
+    }
+    return endpoints;
+  }
+  collectEndpointClients(clientCalls) {
+    const byRepo = /* @__PURE__ */ new Map();
+    for (const call of clientCalls) {
+      const repo = call.source_repo_name;
+      if (!byRepo.has(repo)) byRepo.set(repo, []);
+      byRepo.get(repo).push(call);
+    }
+    const clients = [];
+    for (const [repoName, calls] of byRepo) {
+      const repo = this.topoStore.getFederatedRepo(repoName);
+      for (const call of calls) {
+        const symbols = repo?.db_path && fs23.existsSync(repo.db_path) ? resolveSymbolsAtLocation(repo.db_path, call.file_path, call.line) : [];
+        clients.push({
+          repo: repoName,
+          filePath: call.file_path,
+          line: call.line,
+          callType: call.call_type,
+          confidence: call.confidence,
+          symbols
+        });
+      }
+    }
+    return clients;
+  }
+  detectBreakingChanges(ep) {
+    const contracts = this.topoStore.getContractsByService(ep.service_id);
+    for (const contract of contracts) {
+      const snapshot = this.topoStore.getLatestSnapshot(contract.id);
+      if (!snapshot) continue;
+      let oldEndpoints = [];
+      try {
+        const parsed = JSON.parse(snapshot.endpoints_json);
+        oldEndpoints = (parsed.endpoints ?? []).map((e) => ({ method: e.method ?? null, path: e.path, requestSchema: e.requestSchema, responseSchema: e.responseSchema }));
+      } catch {
+        continue;
+      }
+      const currentEndpoints = this.topoStore.getEndpointsByService(ep.service_id).map((e) => ({
+        method: e.method,
+        path: e.path,
+        requestSchema: e.request_schema,
+        responseSchema: e.response_schema
+      }));
+      const epDiffs = diffEndpoints(oldEndpoints, currentEndpoints).filter((d) => d.endpoint.path === ep.path && (d.endpoint.method ?? "*") === (ep.method ?? "*"));
+      if (epDiffs.length > 0 && epDiffs.some((d) => d.breaking)) {
+        return epDiffs;
+      }
+    }
+    return void 0;
+  }
   /**
    * Search across all federated repos. Opens each per-repo DB readonly,
    * runs FTS search, normalizes scores, merges results.
@@ -12277,6 +12060,18 @@ var FederationManager = class {
     }
   }
 };
+function computeRiskLevel(uniqueRepoCount, clientCount) {
+  if (uniqueRepoCount >= 3) return "critical";
+  if (uniqueRepoCount >= 2) return "high";
+  if (clientCount >= 3) return "medium";
+  return "low";
+}
+function upgradeRiskIfBreaking(risk, breakingChanges) {
+  if (!breakingChanges?.some((d) => d.breaking)) return risk;
+  const levels = ["low", "medium", "high", "critical"];
+  const idx = levels.indexOf(risk);
+  return idx < levels.length - 1 ? levels[idx + 1] : risk;
+}
 function resolveSymbolsAtLocation(dbPath, filePath, line) {
   if (!line) return [];
   try {
@@ -22465,13 +22260,13 @@ function detectDrift(store, cwd, options = {}) {
     const commitsB = fileCommitCount.get(fileB) ?? 0;
     const denominator = commitsA + commitsB - count;
     if (denominator <= 0) continue;
-    const jaccard3 = count / denominator;
-    if (jaccard3 < minConfidence) continue;
+    const jaccard2 = count / denominator;
+    if (jaccard2 < minConfidence) continue;
     anomalies.push({
       file_a: fileA,
       file_b: fileB,
       co_change_count: count,
-      confidence: round2(jaccard3),
+      confidence: round2(jaccard2),
       module_a: moduleA,
       module_b: moduleB
     });
@@ -28797,7 +28592,7 @@ var TopologyStore = class {
 };
 
 // src/server/server.ts
-var PKG_VERSION = true ? "1.9.0" : "0.0.0-dev";
+var PKG_VERSION = true ? "1.10.0" : "0.0.0-dev";
 function j2(value) {
   return JSON.stringify(value, (_key, val) => val === null || val === void 0 ? void 0 : val);
 }