weavatrix 0.2.12 → 0.2.14

package/src/graph/internal-builder.pass2.js

@@ -0,0 +1,161 @@
+import {readFileSync} from 'node:fs'
+import {extname} from 'node:path'
+import {Parser, EXT_LANG, FAMILY, LANGS} from './internal-builder.langs.js'
+import {addJavaReferences} from './internal-builder.java.js'
+import {resolveJsBarrels} from './internal-builder.barrels.js'
+import {createPass2Resolution} from './builder/pass2-resolution.js'
+import {createGoReceiverResolution} from './builder/go-receiver-resolution.js'
+
+export function runInternalGraphPass2({
+    files, rel, langs, caps, field, links, nodeById, perFileSymbols, symByFileName,
+    symIdsByFileName, importedLocals, jsExports,
+}) {
+    const resolution = createPass2Resolution({symIdsByFileName, nodeById, importedLocals, symByFileName})
+    const {dirSymbols, resolveNamedSymbol, resolveCall, resolveJavaType} = resolution
+    const {resolveNamespaceMember, reExportOccurrences} = resolveJsBarrels({
+        jsExports, importedLocals, links,
+        resolveSymbol: (file, name, typeOnly) => resolveNamedSymbol(file, name, typeOnly ? 'type' : 'value'),
+    })
+    const enclosing = (file, line) => {
+        let best = null
+        for (const symbol of perFileSymbols.get(file) || []) {
+            if (line < symbol.start || line > symbol.end) continue
+            if (!best || symbol.start > best.start || (symbol.start === best.start && symbol.end < best.end)) best = symbol
+        }
+        return best
+    }
+    const goReceivers = createGoReceiverResolution({resolution, nodeById, importedLocals})
+    for (const absolute of files) {
+        const file = rel(absolute), grammar = EXT_LANG[extname(absolute)]
+        if (!grammar) continue
+        const lang = LANGS[FAMILY[grammar]]
+        if (!lang || lang.isWeb || !langs[grammar]) continue
+        let code
+        try { code = readFileSync(absolute, 'utf8') } catch { continue }
+        const parser = new Parser()
+        parser.setLanguage(langs[grammar])
+        let tree
+        try { tree = parser.parse(code) } catch { continue }
+        if (!lang.customCalls) for (const capture of caps(grammar, lang.calls, tree.rootNode)) {
+            const caller = enclosing(file, capture.node.startPosition.row + 1)
+            if (!caller) continue
+            const target = resolveCall(capture.node.text, file)
+            if (target && target !== caller.id) links.push({source: caller.id, target, relation: 'calls', confidence: 'INFERRED', line: capture.node.startPosition.row + 1})
+        }
+        if (typeof lang.pass2 === 'function') try {
+            lang.pass2({
+                grammar, tree, fileRel: file, code, caps, field, enclosing, links, nodeById,
+                perFileSymbols, symByFileName, symIdsByFileName, importedLocals, resolveCall, resolveJavaType,
+            })
+        } catch { /* one language-specific resolver never sinks the graph */ }
+        if (lang.selectorCall) for (const capture of caps(grammar, lang.selectorCall, tree.rootNode)) {
+            const selector = capture.node, operand = field(selector, 'operand'), member = field(selector, 'field')
+            if (!operand || !member) continue
+            const caller = enclosing(file, selector.startPosition.row + 1)
+            if (!caller) continue
+            const bindings = goReceivers.receiverBindings(selector, file)
+            const imported = operand.type === 'identifier' && !bindings.has(operand.text)
+                ? importedLocals.get(file)?.get(operand.text) : null
+            let target = imported?.targetDir ? dirSymbols.get(imported.targetDir)?.get(member.text) : null
+            let resolved = !!target
+            if (!target) {
+                let receiver = null
+                if (operand.type === 'identifier') receiver = bindings.get(operand.text) || null
+                else if (operand.type === 'selector_expression') {
+                    const base = field(operand, 'operand')
+                    const baseType = base?.type === 'identifier' ? bindings.get(base.text) : null
+                    receiver = goReceivers.fieldType(baseType, field(operand, 'field')?.text)
+                }
+                target = goReceivers.exactMethod(receiver, member.text)
+                resolved = !!target
+                if (!target && !receiver) target = goReceivers.uniqueMethod(goReceivers.dirOf(file), member.text)
+            }
+            if (target && target !== caller.id) links.push({
+                source: caller.id, target, relation: 'calls', confidence: 'INFERRED',
+                ...(resolved ? {provenance: 'RESOLVED'} : {}), line: selector.startPosition.row + 1,
+            })
+        }
+        for (const heritageSpec of lang.heritage || []) {
+            const query = typeof heritageSpec === 'string' ? heritageSpec : heritageSpec.query
+            const relation = typeof heritageSpec === 'string' ? 'inherits' : (heritageSpec.relation || 'inherits')
+            for (const capture of caps(grammar, query, tree.rootNode)) {
+                const owner = enclosing(file, capture.node.startPosition.row + 1)
+                if (!owner) continue
+                const target = FAMILY[grammar] === 'java' ? resolveJavaType(capture.node.text, file) : resolveCall(capture.node.text, file)
+                if (target && target !== owner.id) links.push({source: owner.id, target, relation, confidence: 'INFERRED'})
+            }
+        }
+        if (FAMILY[grammar] === 'js') addJavaScriptReferences({
+            grammar, tree, file, caps, field, importedLocals, resolveNamespaceMember,
+            resolveNamedSymbol, enclosing, links,
+        })
+        if (FAMILY[grammar] === 'go') addGoReferences({
+            grammar, tree, file, caps, field, importedLocals, dirSymbols, enclosing, links,
+        })
+        if (FAMILY[grammar] === 'java') addJavaReferences({grammar, tree, fileRel: file, caps, resolveJavaType, enclosing, links})
+        tree.delete()
+    }
+    return {reExportOccurrences}
+}
+
+function addJavaScriptReferences({grammar, tree, file, caps, field, importedLocals, resolveNamespaceMember, resolveNamedSymbol, enclosing, links}) {
+    for (const capture of caps(grammar, `(call_expression function: (member_expression) @memberCall)`, tree.rootNode)) {
+        const object = field(capture.node, 'object'), property = field(capture.node, 'property')
+        if (!object || object.type !== 'identifier' || !property) continue
+        const imported = importedLocals.get(file)?.get(object.text)
+        if (!imported || !['*', 'default'].includes(imported.imported) || imported.typeOnly) continue
+        const origin = resolveNamespaceMember(file, imported, property.text, 'call')
+        if (origin.status !== 'resolved') continue
+        const target = resolveNamedSymbol(origin.origin.file, origin.origin.name, 'value')
+        const caller = enclosing(file, capture.node.startPosition.row + 1)
+        if (target && caller && target !== caller.id) links.push({source: caller.id, target, relation: 'calls', confidence: 'INFERRED', line: capture.node.startPosition.row + 1})
+    }
+    for (const capture of caps(grammar, `[(jsx_opening_element name: (_) @jsx) (jsx_self_closing_element name: (_) @jsx)]`, tree.rootNode)) {
+        const parts = capture.node.text.split('.'), localName = parts[0]
+        if (parts.length === 1 && !/^[A-Z_$]/.test(localName)) continue
+        const imported = importedLocals.get(file)?.get(localName)
+        if (!imported?.targetFile || imported.typeOnly) continue
+        let targetFile = imported.originFile || imported.targetFile
+        let importedName = imported.originName || imported.imported
+        if (imported.imported === '*' && parts.length > 1) {
+            const origin = resolveNamespaceMember(file, imported, parts.at(-1), 'jsx')
+            if (origin.status === 'resolved') { targetFile = origin.origin.file; importedName = origin.origin.name }
+        }
+        const target = resolveNamedSymbol(targetFile, importedName, 'value') || resolveNamedSymbol(targetFile, localName, 'value')
+        if (!target) continue
+        const owner = enclosing(file, capture.node.startPosition.row + 1)
+        links.push({source: owner?.id || file, target, relation: 'references', confidence: 'INFERRED', usage: 'jsx', line: capture.node.startPosition.row + 1})
+    }
+    if (grammar === 'javascript') return
+    for (const capture of caps(grammar, `(type_identifier) @typeRef`, tree.rootNode)) {
+        const name = capture.node.text, imported = importedLocals.get(file)?.get(name)
+        const targetFile = imported?.originFile || imported?.targetFile || file
+        const targetName = imported?.originName || imported?.imported || name
+        const target = resolveNamedSymbol(targetFile, targetName, 'type')
+        if (!target || String(target).startsWith(`${file}#${name}@${capture.node.startPosition.row + 1}`)) continue
+        const source = enclosing(file, capture.node.startPosition.row + 1)?.id || file
+        if (source !== target) links.push({source, target, relation: 'references', confidence: 'EXTRACTED', provenance: 'RESOLVED', typeOnly: true, line: capture.node.startPosition.row + 1, usage: 'type'})
+    }
+}
+
+function addGoReferences({grammar, tree, file, caps, field, importedLocals, dirSymbols, enclosing, links}) {
+    const seen = new Set()
+    const emit = (source, target) => {
+        const key = `${source}>${target}`
+        if (!target || target === source || seen.has(key)) return
+        seen.add(key); links.push({source, target, relation: 'references', confidence: 'INFERRED'})
+    }
+    const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : '', symbols = dirSymbols.get(dir)
+    for (const capture of caps(grammar, `[(identifier) (type_identifier)] @id`, tree.rootNode)) {
+        const target = symbols?.get(capture.node.text)
+        if (!target || target.slice(0, target.indexOf('#')) === file) continue
+        emit(enclosing(file, capture.node.startPosition.row + 1)?.id || file, target)
+    }
+    for (const capture of caps(grammar, `(selector_expression) @sel`, tree.rootNode)) {
+        const selector = capture.node, operand = field(selector, 'operand'), member = field(selector, 'field')
+        if (!operand || operand.type !== 'identifier' || !member) continue
+        const imported = importedLocals.get(file)?.get(operand.text)
+        const target = imported?.targetDir && dirSymbols.get(imported.targetDir)?.get(member.text)
+        if (target) emit(enclosing(file, selector.startPosition.row + 1)?.id || file, target)
+    }
+}

package/src/graph/internal-builder.resolvers.js

@@ -6,6 +6,7 @@ import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { parseGoMod } from "../analysis/manifests.js";
 import { createRepoBoundary } from "../repo-path.js";
+import { createRustResolvers } from "./resolvers/rust.js";
 
 export function buildResolvers(repoDir, fileSet) {
   const boundary = createRepoBoundary(repoDir);
@@ -48,111 +49,7 @@ export function buildResolvers(repoDir, fileSet) {
     return cands.find((f) => f === full || f.endsWith("/" + full)) || cands[0] || null;
   };
 
-  // Rust modules are files, but their paths are logical rather than simple source-relative imports:
-  // `foo.rs` owns children below `foo/`, while lib.rs/main.rs/mod.rs own siblings. Keep the resolver
-  // filesystem-only and crate-local: Cargo/external dependencies belong to dependency analysis, not to
-  // the internal module graph.
-  const cleanRustRel = (p) => String(p || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/+/g, "/").replace(/\/$/, "").replace(/^\.$/, "");
-  const rustDir = (p) => { p = cleanRustRel(p); const i = p.lastIndexOf("/"); return i < 0 ? "" : p.slice(0, i); };
-  const rustBase = (p) => { p = cleanRustRel(p); const i = p.lastIndexOf("/"); return i < 0 ? p : p.slice(i + 1); };
-  const rustJoin = (...parts) => cleanRustRel(join(...parts.filter((x) => x != null && x !== "")));
-  const rustFiles = new Set([...fileSet].filter((fr) => fr.endsWith(".rs")));
-  const rustRoots = new Map();
-  for (const fr of rustFiles) {
-    const base = rustBase(fr);
-    if (base !== "lib.rs" && base !== "main.rs") continue;
-    const dir = rustDir(fr);
-    let root = rustRoots.get(dir);
-    if (!root) rustRoots.set(dir, (root = { base: dir, lib: null, main: null }));
-    root[base === "lib.rs" ? "lib" : "main"] = fr;
-  }
-  const rustRootList = [...rustRoots.values()].sort((a, b) => b.base.length - a.base.length);
-  const rustContext = (fromRel) => {
-    fromRel = cleanRustRel(fromRel);
-    const base = rustBase(fromRel);
-    const dir = rustDir(fromRel);
-    if (base === "lib.rs" || base === "main.rs") return { base: dir, rootFile: fromRel };
-
-    // Cargo treats direct files in these conventional folders as independent crate roots. This only
-    // affects paths originating in the root file itself; nested module ownership still comes from mod/use.
-    if (/^(?:bin|examples|tests|benches)$/.test(rustBase(dir))) return { base: dir, rootFile: fromRel };
-    for (const root of rustRootList) {
-      if (!root.base || fromRel.startsWith(root.base + "/")) return { base: root.base, rootFile: root.lib || root.main };
-    }
-    return { base: dir, rootFile: fromRel };
-  };
-  const rustModuleBase = (fromRel) => {
-    const ctx = rustContext(fromRel);
-    if (ctx.rootFile === cleanRustRel(fromRel)) return rustDir(fromRel);
-    const name = rustBase(fromRel);
-    if (name === "lib.rs" || name === "main.rs" || name === "mod.rs") return rustDir(fromRel);
-    return rustJoin(rustDir(fromRel), name.replace(/\.rs$/, ""));
-  };
-  const rustInlineBase = (fromRel, inlineModules = []) => {
-    let base = rustModuleBase(fromRel);
-    for (let i = 0; i < inlineModules.length; i++) {
-      const mod = inlineModules[i] || {};
-      if (mod.path) {
-        // Rust Reference: a path attribute on the first inline module is relative to the source file's
-        // directory; nested attributes are relative to their containing module's search directory.
-        const parent = i === 0 ? rustDir(fromRel) : base;
-        base = rustJoin(parent, mod.path);
-      } else base = rustJoin(base, mod.name);
-    }
-    return base;
-  };
-  const rustModuleFile = (moduleBase, ctx) => {
-    moduleBase = cleanRustRel(moduleBase);
-    if (moduleBase === cleanRustRel(ctx.base) && ctx.rootFile && rustFiles.has(ctx.rootFile)) return ctx.rootFile;
-    const flat = moduleBase + ".rs";
-    if (rustFiles.has(flat)) return flat;
-    const legacy = rustJoin(moduleBase, "mod.rs");
-    return rustFiles.has(legacy) ? legacy : null;
-  };
-  const resolveRustMod = (fromRel, name, { inlineModules = [], explicitPath = "" } = {}) => {
-    fromRel = cleanRustRel(fromRel);
-    if (explicitPath) {
-      const parent = inlineModules.length ? rustInlineBase(fromRel, inlineModules) : rustDir(fromRel);
-      const target = rustJoin(parent, explicitPath);
-      return rustFiles.has(target) ? target : null;
-    }
-    const targetBase = rustJoin(rustInlineBase(fromRel, inlineModules), String(name || "").replace(/^r#/, ""));
-    return rustModuleFile(targetBase, rustContext(fromRel));
-  };
-  const resolveRustPath = (fromRel, rawSegments, { inlineModules = [], unqualified = true } = {}) => {
-    fromRel = cleanRustRel(fromRel);
-    const segments = (Array.isArray(rawSegments) ? rawSegments : String(rawSegments || "").split("::"))
-      .map((s) => String(s).trim().replace(/^r#/, "")).filter(Boolean);
-    if (!segments.length) return null;
-    const ctx = rustContext(fromRel);
-    const current = rustInlineBase(fromRel, inlineModules);
-    let rest = [...segments];
-    const starts = [];
-    let anchored = false;
-    if (rest[0] === "crate") { anchored = true; rest.shift(); starts.push(ctx.base); }
-    else if (rest[0] === "self") { anchored = true; rest.shift(); starts.push(current); }
-    else if (rest[0] === "super") {
-      anchored = true;
-      let base = current;
-      while (rest[0] === "super") { rest.shift(); base = rustDir(base); }
-      if (ctx.base && base !== ctx.base && !base.startsWith(ctx.base + "/")) return null;
-      starts.push(base);
-    } else if (unqualified) {
-      // Rust 2018 resolves a bare use path from the crate root/external prelude. Prefer an internal root
-      // module, then allow a lexically-local module for qualified expressions in nested modules.
-      starts.push(ctx.base);
-      if (current !== ctx.base) starts.push(current);
-    } else return null;
-
-    for (const start of starts) {
-      const min = anchored ? 0 : 1; // never reinterpret an unresolved external `serde::X` as the crate root
-      for (let used = rest.length; used >= min; used--) {
-        const target = rustModuleFile(rustJoin(start, ...rest.slice(0, used)), ctx);
-        if (target) return { targetFile: target, consumed: segments.length - rest.length + used, remaining: rest.slice(used), anchored };
-      }
-    }
-    return null;
-  };
+  const { resolveRustMod, resolveRustPath } = createRustResolvers(fileSet);
 
   // Path aliases (tsconfig compilerOptions.paths + vite/webpack alias) are scoped to their config folder.
   // Without nearest-config resolution, a monorepo's root `@/*` can hijack the same alias in web/.

package/src/graph/resolvers/rust.js

@@ -0,0 +1,117 @@
+import {join} from 'node:path'
+
+const cleanRustRel = (path) => String(path || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+/g, '/').replace(/\/$/, '').replace(/^\.$/, '')
+const rustDir = (path) => {
+  const clean = cleanRustRel(path)
+  const index = clean.lastIndexOf('/')
+  return index < 0 ? '' : clean.slice(0, index)
+}
+const rustBase = (path) => {
+  const clean = cleanRustRel(path)
+  const index = clean.lastIndexOf('/')
+  return index < 0 ? clean : clean.slice(index + 1)
+}
+const rustJoin = (...parts) => cleanRustRel(join(...parts.filter((part) => part != null && part !== '')))
+
+export function createRustResolvers(fileSet) {
+  const rustFiles = new Set([...fileSet].filter((file) => file.endsWith('.rs')))
+  const rustRoots = new Map()
+  for (const file of rustFiles) {
+    const base = rustBase(file)
+    if (base !== 'lib.rs' && base !== 'main.rs') continue
+    const dir = rustDir(file)
+    let root = rustRoots.get(dir)
+    if (!root) rustRoots.set(dir, (root = {base: dir, lib: null, main: null}))
+    root[base === 'lib.rs' ? 'lib' : 'main'] = file
+  }
+  const rustRootList = [...rustRoots.values()].sort((a, b) => b.base.length - a.base.length)
+
+  const rustContext = (fromRel) => {
+    const clean = cleanRustRel(fromRel)
+    const base = rustBase(clean)
+    const dir = rustDir(clean)
+    if (base === 'lib.rs' || base === 'main.rs') return {base: dir, rootFile: clean}
+    if (/^(?:bin|examples|tests|benches)$/.test(rustBase(dir))) return {base: dir, rootFile: clean}
+    for (const root of rustRootList) {
+      if (!root.base || clean.startsWith(root.base + '/')) return {base: root.base, rootFile: root.lib || root.main}
+    }
+    return {base: dir, rootFile: clean}
+  }
+  const rustModuleBase = (fromRel) => {
+    const context = rustContext(fromRel)
+    if (context.rootFile === cleanRustRel(fromRel)) return rustDir(fromRel)
+    const name = rustBase(fromRel)
+    if (name === 'lib.rs' || name === 'main.rs' || name === 'mod.rs') return rustDir(fromRel)
+    return rustJoin(rustDir(fromRel), name.replace(/\.rs$/, ''))
+  }
+  const rustInlineBase = (fromRel, inlineModules = []) => {
+    let base = rustModuleBase(fromRel)
+    for (let index = 0; index < inlineModules.length; index++) {
+      const module = inlineModules[index] || {}
+      if (module.path) {
+        const parent = index === 0 ? rustDir(fromRel) : base
+        base = rustJoin(parent, module.path)
+      } else base = rustJoin(base, module.name)
+    }
+    return base
+  }
+  const rustModuleFile = (moduleBase, context) => {
+    const clean = cleanRustRel(moduleBase)
+    if (clean === cleanRustRel(context.base) && context.rootFile && rustFiles.has(context.rootFile)) return context.rootFile
+    const flat = clean + '.rs'
+    if (rustFiles.has(flat)) return flat
+    const legacy = rustJoin(clean, 'mod.rs')
+    return rustFiles.has(legacy) ? legacy : null
+  }
+
+  const resolveRustMod = (fromRel, name, {inlineModules = [], explicitPath = ''} = {}) => {
+    const clean = cleanRustRel(fromRel)
+    if (explicitPath) {
+      const parent = inlineModules.length ? rustInlineBase(clean, inlineModules) : rustDir(clean)
+      const target = rustJoin(parent, explicitPath)
+      return rustFiles.has(target) ? target : null
+    }
+    const targetBase = rustJoin(rustInlineBase(clean, inlineModules), String(name || '').replace(/^r#/, ''))
+    return rustModuleFile(targetBase, rustContext(clean))
+  }
+
+  const resolveRustPath = (fromRel, rawSegments, {inlineModules = [], unqualified = true} = {}) => {
+    const clean = cleanRustRel(fromRel)
+    const segments = (Array.isArray(rawSegments) ? rawSegments : String(rawSegments || '').split('::'))
+      .map((segment) => String(segment).trim().replace(/^r#/, '')).filter(Boolean)
+    if (!segments.length) return null
+    const context = rustContext(clean)
+    const current = rustInlineBase(clean, inlineModules)
+    const rest = [...segments]
+    const starts = []
+    let anchored = false
+    if (rest[0] === 'crate') { anchored = true; rest.shift(); starts.push(context.base) }
+    else if (rest[0] === 'self') { anchored = true; rest.shift(); starts.push(current) }
+    else if (rest[0] === 'super') {
+      anchored = true
+      let base = current
+      while (rest[0] === 'super') { rest.shift(); base = rustDir(base) }
+      if (context.base && base !== context.base && !base.startsWith(context.base + '/')) return null
+      starts.push(base)
+    } else if (unqualified) {
+      starts.push(context.base)
+      if (current !== context.base) starts.push(current)
+    } else return null
+
+    for (const start of starts) {
+      const minimum = anchored ? 0 : 1
+      for (let used = rest.length; used >= minimum; used--) {
+        const target = rustModuleFile(rustJoin(start, ...rest.slice(0, used)), context)
+        if (target) return {
+          targetFile: target,
+          consumed: segments.length - rest.length + used,
+          remaining: rest.slice(used),
+          anchored,
+        }
+      }
+    }
+    return null
+  }
+
+  return {resolveRustMod, resolveRustPath}
+}

package/src/mcp/actions/advisories.mjs

@@ -0,0 +1,18 @@
+import {refreshAdvisories, storeMeta, DEFAULT_STORE} from '../../security/advisory-store.js'
+import {collectInstalled} from '../../security/installed.js'
+
+export async function tRefreshAdvisories(g, args, ctx) {
+    if (!ctx.repoRoot) return 'No repo root — cannot collect installed packages.'
+    const {installed} = collectInstalled(ctx.repoRoot)
+    if (!installed.length) return 'No pinned packages found in lockfiles (npm/yarn/pip/poetry/uv/go) — nothing to query.'
+    const res = await refreshAdvisories({installed, repoKey: ctx.repoRoot, timeoutMs: Number(args.timeout_ms) || undefined})
+    if (res.ok === false) return `Advisory refresh failed: ${res.error}`
+    const meta = storeMeta()
+    return [
+        `Advisory store ${res.status === 'PARTIAL' ? 'partially refreshed' : 'refreshed'} from OSV.dev: ${res.queriedOk ?? res.queried}/${res.queried} package versions queried successfully, ${res.vulnerable} with known advisories (${res.fetched} advisory records fetched).`,
+        res.unsupported ? `${res.unsupported} packages skipped (ecosystem not OSV-queryable — npm/PyPI/Go only).` : null,
+        res.errors?.length ? `Partial: ${res.errors.length} request error(s), first: ${res.errors[0]}` : null,
+        `Store: ${DEFAULT_STORE} (${meta.advisoryCount} advisories, fetched ${meta.fetchedAt}). run_audit now reflects it — offline.`,
+    ].filter(Boolean).join('\n')
+}
+

package/src/mcp/actions/graph-lifecycle.mjs

@@ -0,0 +1,148 @@
+import {existsSync, readFileSync, realpathSync, statSync, writeFileSync} from 'node:fs'
+import {dirname, isAbsolute, join} from 'node:path'
+import {diffGraphs, formatGraphDiff, prevGraphPathFor} from '../graph-context.mjs'
+import {buildGraphForRepo, defaultPrecisionMode} from '../../build-graph.js'
+import {graphHomeDir, graphOutDirForModule, graphOutDirForRepo} from '../../graph/layout.js'
+import {liveRepositoryRecords, registerRepository} from '../../graph/repo-registry.js'
+import {precisionSemanticInputsMatch, readPrecisionOverlay} from '../../precision/lsp-overlay.js'
+
+export async function tRebuildGraph(g, args, ctx) {
+    if (!ctx.repoRoot) return 'Rebuild needs the repo root (not provided to this server).'
+    const mode = ['no-tests', 'tests-only', 'full'].includes(args.mode)
+        ? args.mode
+        : ['no-tests', 'tests-only', 'full'].includes(g?.graphBuildMode) ? g.graphBuildMode : 'full'
+    const precision = args.precision === 'off' ? 'off' : args.precision === 'lsp' ? 'lsp' : (g?.graphPrecisionMode || defaultPrecisionMode())
+    const scope = String(args.scope || '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '')
+    if (scope) {
+        const scopedDir = graphOutDirForModule(ctx.repoRoot, scope)
+        const scoped = await buildGraphForRepo(ctx.repoRoot, {mode, scope, precision, outDir: scopedDir})
+        if (!scoped || !scoped.ok) return `Scoped graph build failed: ${(scoped && scoped.error) || 'unknown error'}`
+        return [
+            `Built an isolated scoped graph for ${scope} (${mode}). ${scoped.log || ''}.`,
+            `The active full-repository graph was not replaced, so this operation cannot report a false full→scope structural delta.`,
+            `Scoped graph: ${join(scopedDir, 'graph.json')}`,
+        ].join('\n')
+    }
+    // snapshot the outgoing state: bytes → graph.prev.json (for graph_diff later), struct → inline delta
+    let prevBytes = null
+    try { prevBytes = readFileSync(ctx.graphPath) } catch { /* first build — nothing to diff against */ }
+    let before = null
+    try { before = prevBytes ? JSON.parse(prevBytes.toString('utf8')) : null } catch { before = null }
+    const res = await buildGraphForRepo(ctx.repoRoot, {mode, scope: '', precision, outDir: ctx.graphPath ? dirname(ctx.graphPath) : undefined})
+    if (!res || !res.ok) return `Graph rebuild failed: ${(res && res.error) || 'unknown error'}`
+    if (prevBytes) { try { writeFileSync(prevGraphPathFor(ctx.graphPath), prevBytes) } catch { /* snapshot is best-effort */ } }
+    const fresh = ctx.reload() // refresh THIS server's in-memory graph so subsequent tool calls see the new graph
+    let afterStatic = null
+    try { afterStatic = JSON.parse(readFileSync(ctx.graphPath, 'utf8')) } catch { /* reload already reports the failure */ }
+    const beforeMode = ['full', 'no-tests', 'tests-only'].includes(before?.graphBuildMode) ? before.graphBuildMode : 'full'
+    const afterMode = ['full', 'no-tests', 'tests-only'].includes(afterStatic?.graphBuildMode) ? afterStatic.graphBuildMode : 'full'
+    const delta = before && afterStatic
+        ? beforeMode === afterMode
+            ? formatGraphDiff(diffGraphs(before, afterStatic))
+            : `Structural delta not computed: build mode changed from ${beforeMode} to ${afterMode}, so the node/edge universes are not comparable.`
+        : null
+    return [
+        `Rebuilt the graph (${mode}). ${res.log || ''}. In-memory graph reloaded — graph tools now reflect it.`,
+        delta
+    ].filter(Boolean).join('\n\n')
+}
+
+// Retarget this server at ANOTHER local repository at runtime — one weavatrix registration serves any
+// repo. Loads <parent>/weavatrix-graphs/<name>/graph.json (the central layout graphs
+// always live in), building it first when missing. On a failed load the previous repo stays active.
+export async function tOpenRepo(g, args, ctx) {
+
+    const requestedPath = String(args.path || '').trim()
+    if (!requestedPath) return 'Provide "path" — an absolute path to a local repository folder.'
+    if (!isAbsolute(requestedPath)) return 'open_repo requires an absolute repository path.'
+    let repoPath
+    try { repoPath = realpathSync.native(requestedPath) } catch { return `Path not found: ${requestedPath}` }
+    try { if (!statSync(repoPath).isDirectory()) return `Not a directory: ${requestedPath}` } catch { return `Path not found: ${requestedPath}` }
+    if (!existsSync(join(repoPath, '.git'))) return `Not a Git repository: ${requestedPath}`
+    const graphPath = join(graphOutDirForRepo(repoPath), 'graph.json')
+    const graphExists = existsSync(graphPath)
+    const requestedMode = ['no-tests', 'tests-only', 'full'].includes(args.mode) ? args.mode : null
+    const requestedPrecision = ['lsp', 'off'].includes(args.precision) ? args.precision : null
+    let built = false
+    let upgrade = false
+    let schemaUpgrade = false
+    let precisionUpgrade = false
+    let savedMode = 'full'
+    let savedPrecision = defaultPrecisionMode()
+    if (graphExists) {
+        try {
+            const saved = JSON.parse(readFileSync(graphPath, 'utf8'))
+            savedMode = ['no-tests', 'tests-only', 'full'].includes(saved.graphBuildMode) ? saved.graphBuildMode : 'full'
+            savedPrecision = ['lsp', 'off'].includes(saved.graphPrecisionMode) ? saved.graphPrecisionMode : defaultPrecisionMode()
+            schemaUpgrade = !Number.isInteger(saved.edgeTypesV) || saved.edgeTypesV < 2
+                || !Number.isInteger(saved.edgeProvenanceV) || saved.edgeProvenanceV < 1
+                || !Number.isInteger(saved.extractorSchemaV) || saved.extractorSchemaV < 5
+                || !Number.isInteger(saved.reExportOccurrencesV) || saved.reExportOccurrencesV < 1
+                || !Number.isInteger(saved.symbolSpacesV) || saved.symbolSpacesV < 1
+                || !Number.isInteger(saved.physicalFileLocV) || saved.physicalFileLocV < 1
+            if (savedPrecision === 'lsp') {
+                const overlay = readPrecisionOverlay(graphPath, saved)
+                precisionUpgrade = !overlay || (typeof overlay.semanticInputFingerprint === 'string'
+                    && !precisionSemanticInputsMatch(overlay, repoPath, saved))
+            }
+            upgrade = schemaUpgrade || precisionUpgrade
+        } catch {
+            upgrade = true
+        }
+    }
+    const modeMismatch = graphExists && requestedMode != null && requestedMode !== savedMode
+    const precisionMismatch = graphExists && requestedPrecision != null && requestedPrecision !== savedPrecision
+    if (!graphExists || upgrade || modeMismatch || precisionMismatch) {
+        if (args.build === false) {
+            if (modeMismatch && !upgrade) {
+                return `The existing graph for ${repoPath} was built in ${savedMode}, but ${requestedMode} was requested. Re-call without build:false to rebuild it before switching.`
+            }
+            if (precisionMismatch && !upgrade) {
+                return `The existing graph for ${repoPath} uses semantic precision ${savedPrecision}, but ${requestedPrecision} was requested. Re-call without build:false to rebuild it before switching.`
+            }
+            return upgrade
+                ? precisionUpgrade && !schemaUpgrade
+                    ? `The existing graph for ${repoPath} lacks current revision-matched semantic precision evidence. Re-call without build:false to refresh it before switching.`
+                    : `The existing graph for ${repoPath} predates current graph metadata (typed edges, provenance, or physical file LOC). Re-call without build:false to upgrade it before switching.`
+                : `No graph yet for ${repoPath} (expected at ${graphPath}). Re-call without build:false to build one — large repos can take minutes.`
+        }
+        const mode = requestedMode || (graphExists ? savedMode : 'full')
+        const precision = requestedPrecision || (graphExists ? savedPrecision : defaultPrecisionMode())
+        const res = await buildGraphForRepo(repoPath, {mode, scope: '', precision})
+        if (!res || !res.ok) return `Graph build failed for ${repoPath}: ${(res && res.error) || 'unknown error'}`
+        built = true
+    }
+    const prev = {graphPath: ctx.graphPath, repoRoot: ctx.repoRoot}
+    ctx.graphPath = graphPath
+    ctx.repoRoot = repoPath
+    const loaded = ctx.reload()
+    if (!loaded) {
+        ctx.graphPath = prev.graphPath
+        ctx.repoRoot = prev.repoRoot
+        ctx.reload()
+        return `Failed to load ${graphPath} — still targeting the previous repo (${prev.repoRoot || 'none'}).`
+    }
+    registerRepository({repoPath, graphDir: graphOutDirForRepo(repoPath), graphHome: graphHomeDir()})
+    const buildNote = built ? (upgrade ? ' (graph upgraded to current edge/precision metadata)' : modeMismatch ? ' (graph rebuilt in the requested mode)' : precisionMismatch ? ' (semantic precision mode updated)' : ' (graph built fresh)') : ''
+    return [
+        `Opened ${repoPath}${buildNote}: ${loaded.nodes.length} nodes / ${loaded.links.length} edges. All tools now target this repo.`,
+        `Graph: ${graphPath}`,
+        `Build mode: ${loaded.graphBuildMode || 'full'}`,
+        `Semantic precision: ${loaded.precision?.state || 'UNAVAILABLE'} (${loaded.precision?.verifiedEdges || 0} EXACT_LSP edge(s))`,
+    ].join('\n')
+}
+
+// Sibling repos that already have a built graph in the central weavatrix-graphs folder — open_repo candidates.
+export function tListKnownRepos(g, args, ctx) {
+    const root = graphHomeDir()
+    const norm = (p) => String(p).replace(/[\\/]+/g, '/').toLowerCase()
+    const rows = liveRepositoryRecords(root).map((record) => ({
+        ...record,
+        builtAt: statSync(join(record.graphDir, 'graph.json')).mtime.toISOString(),
+    }))
+    if (!rows.length) return `No registered graphs under ${root}. Build a repository once with open_repo or rebuild_graph.`
+    return [
+        `Known repositories (${rows.length}) in ${root}:`,
+        ...rows.map((r) => `  ${norm(r.repoPath) === norm(ctx.repoRoot) ? '»' : ' '} ${r.label} [${r.repositoryId}] — graph built ${r.builtAt}  (${r.repoPath})`),
+    ].join('\n')
+}