weavatrix 0.2.13 → 0.2.15

package/src/graph/builder/go-receiver-resolution.js

@@ -0,0 +1,112 @@
+import {goTypeName} from './lang-go.js'
+
+const dirOf = (file) => file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
+
+export function createGoReceiverResolution({resolution, nodeById, importedLocals}) {
+    const {dirSymbols, dirMethods, dirMethodsByName, dirTypes, resolveCall} = resolution
+    const typeRef = (rawType, contextFile, fallbackDir = dirOf(contextFile)) => {
+        const raw = String(rawType || '').trim()
+        if (!raw) return null
+        const dot = raw.indexOf('.')
+        if (dot > 0) {
+            const imported = importedLocals.get(contextFile)?.get(raw.slice(0, dot))
+            return imported?.targetDir ? {dir: imported.targetDir, name: raw.slice(dot + 1)} : null
+        }
+        return {dir: fallbackDir, name: raw}
+    }
+    const fieldType = (receiver, fieldName) => {
+        if (!receiver?.name || !fieldName) return null
+        const typeId = dirTypes.get(receiver.dir)?.get(receiver.name)
+        const typeNode = typeId && nodeById.get(typeId)
+        const rawFieldType = typeNode?.field_types?.[fieldName]
+        return rawFieldType ? typeRef(rawFieldType, typeNode.source_file, receiver.dir) : null
+    }
+    const exactMethod = (receiver, methodName) => {
+        const candidates = receiver && dirMethods.get(receiver.dir)?.get(receiver.name)?.get(methodName)
+        return candidates?.length === 1 ? candidates[0] : null
+    }
+    const uniqueMethod = (dir, methodName) => {
+        const candidates = dirMethodsByName.get(dir)?.get(methodName) || []
+        return candidates.length === 1 ? candidates[0] : null
+    }
+    const returnType = (targetId, callerFile) => {
+        const target = targetId && nodeById.get(targetId)
+        return target?.return_type
+            ? typeRef(target.return_type, target.source_file || callerFile, dirOf(target.source_file || callerFile))
+            : null
+    }
+    const fieldChildren = (node, name) => {
+        const children = node?.childrenForFieldName?.(name)
+        if (Array.isArray(children) && children.length) return children
+        const child = node?.childForFieldName?.(name)
+        return child ? [child] : []
+    }
+    const receiverBindings = (selector, file) => {
+        const bindings = new Map()
+        let scope = selector
+        while (scope?.parent && !['function_declaration', 'method_declaration'].includes(scope.type)) scope = scope.parent
+        if (!scope || !['function_declaration', 'method_declaration'].includes(scope.type)) return bindings
+        const callRow = selector.startPosition.row
+        const containsCall = (node) => node.startIndex <= selector.startIndex && node.endIndex >= selector.endIndex
+        const expressionType = (node) => {
+            if (!node) return null
+            const declared = goTypeName(node)
+            if (declared) return typeRef(declared, file)
+            if (['parenthesized_expression', 'unary_expression'].includes(node.type)) {
+                return expressionType(node.childForFieldName?.('operand') || node.namedChildren?.[0])
+            }
+            if (node.type === 'composite_literal') return typeRef(goTypeName(node.childForFieldName?.('type')), file)
+            if (node.type === 'identifier') return bindings.get(node.text) || null
+            if (node.type === 'selector_expression') return fieldType(expressionType(node.childForFieldName?.('operand')), node.childForFieldName?.('field')?.text)
+            if (node.type !== 'call_expression') return null
+            const fn = node.childForFieldName?.('function')
+            if (fn?.type === 'identifier') {
+                const returned = returnType(resolveCall(fn.text, file), file)
+                if (returned) return returned
+                if (dirTypes.get(dirOf(file))?.has(fn.text)) return typeRef(fn.text, file)
+                if (/^New[A-Z_]/.test(fn.text)) return typeRef(fn.text.slice(3), file)
+            }
+            if (fn?.type === 'selector_expression') {
+                const operand = fn.childForFieldName?.('operand'), member = fn.childForFieldName?.('field')?.text
+                const imported = operand?.type === 'identifier' && importedLocals.get(file)?.get(operand.text)
+                if (imported?.targetDir && member) {
+                    const returned = returnType(dirSymbols.get(imported.targetDir)?.get(member), file)
+                    if (returned) return returned
+                    if (/^New[A-Z_]/.test(member)) return {dir: imported.targetDir, name: member.slice(3)}
+                }
+            }
+            return null
+        }
+        const bindTyped = (node) => {
+            const reference = typeRef(goTypeName(node.childForFieldName?.('type')), file)
+            const names = fieldChildren(node, 'name').filter((name) => ['identifier', 'field_identifier'].includes(name.type))
+            if (reference) for (const name of names) bindings.set(name.text, reference)
+            else if (node.type === 'var_spec') {
+                const values = node.childForFieldName?.('value')?.namedChildren || []
+                for (let index = 0; index < Math.min(names.length, values.length); index++) {
+                    const inferred = expressionType(values[index])
+                    if (inferred) bindings.set(names[index].text, inferred)
+                }
+            }
+        }
+        const bindAssignment = (node) => {
+            const left = node.childForFieldName?.('left')?.namedChildren || []
+            const right = node.childForFieldName?.('right')?.namedChildren || []
+            for (let index = 0; index < Math.min(left.length, right.length); index++) {
+                if (left[index].type !== 'identifier') continue
+                const inferred = expressionType(right[index])
+                if (inferred) bindings.set(left[index].text, inferred)
+            }
+        }
+        const visit = (node) => {
+            if (!node || node.startPosition.row > callRow) return
+            if (node !== scope && ['function_declaration', 'method_declaration', 'func_literal'].includes(node.type) && !containsCall(node)) return
+            if (['parameter_declaration', 'var_spec'].includes(node.type)) bindTyped(node)
+            else if (['short_var_declaration', 'assignment_statement'].includes(node.type)) bindAssignment(node)
+            for (const child of node.namedChildren || []) visit(child)
+        }
+        visit(scope)
+        return bindings
+    }
+    return {dirOf, fieldType, exactMethod, uniqueMethod, receiverBindings}
+}

package/src/graph/builder/js/queries.js

@@ -0,0 +1,48 @@
+export const CALLABLE = /arrow_function|function|function_expression|generator_function/
+
+export const FUNCS = `
+  (function_declaration name: (identifier) @fn)
+  (generator_function_declaration name: (identifier) @fn)
+  (class_declaration name: (_) @class)
+  (method_definition name: (_) @method)`
+
+export const TOPVARS = `
+  (program (lexical_declaration (variable_declarator) @decl))
+  (program (variable_declaration (variable_declarator) @decl))
+  (program (export_statement (lexical_declaration (variable_declarator) @decl)))
+  (program (export_statement (variable_declaration (variable_declarator) @decl)))`
+
+export const TYPES = `
+  (interface_declaration name: (_) @interface)
+  (type_alias_declaration name: (_) @type)
+  (enum_declaration name: (_) @enum)`
+
+export const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`
+
+export function parseExportSpecifiers(raw) {
+  return String(raw || '').split(',').map((part) => {
+    const text = part.trim()
+    const typeOnly = /^type\s+/.test(text)
+    const clean = text.replace(/^type\s+/, '').trim()
+    const match = clean.match(/^([A-Za-z_$][\w$]*|default)(?:\s+as\s+([A-Za-z_$][\w$]*|default))?$/)
+    return match ? {imported: match[1], exported: match[2] || match[1], typeOnly} : null
+  }).filter(Boolean)
+}
+
+export function importTypeOnly(node) {
+  if (/^\s*import\s+type\b/.test(node.text)) return true
+  const clause = node.namedChildren.find((child) => child.type === 'import_clause')
+  if (!clause) return false
+  const parts = clause.namedChildren
+  if (parts.some((child) => child.type === 'identifier' || child.type === 'namespace_import')) return false
+  const named = parts.find((child) => child.type === 'named_imports')
+  const specifiers = named?.namedChildren.filter((child) => child.type === 'import_specifier') || []
+  return specifiers.length > 0 && specifiers.every((specifier) => /^\s*type\b/.test(specifier.text))
+}
+
+export function reexportTypeOnly(node) {
+  if (/^\s*export\s+type\b/.test(node.text)) return true
+  const clause = node.namedChildren.find((child) => child.type === 'export_clause')
+  const specifiers = clause?.namedChildren.filter((child) => child.type === 'export_specifier') || []
+  return specifiers.length > 0 && specifiers.every((specifier) => /^\s*type\b/.test(specifier.text))
+}

package/src/graph/builder/lang-go.js

@@ -5,6 +5,61 @@
 // in the orchestrator; cross-pkg `pkg.Func()` is a selector — see resolveGoPackage/pass2). No inheritance.
 import { goSpecToPkg } from "./spec-pkg.js";
 
+// Return the named Go type behind pointers/generics/parentheses. Qualified names are
+// kept (`speaker.Speaker`) so pass 2 can route them through the import alias table.
+export function goTypeName(node) {
+  if (!node) return null;
+  if (node.type === "type_identifier") return node.text;
+  if (node.type === "qualified_type") return node.text.replace(/\s+/g, "");
+  if (node.type === "generic_type") return goTypeName(node.childForFieldName?.("type") || node.namedChildren?.[0]);
+  if (["pointer_type", "parenthesized_type", "unary_expression"].includes(node.type)) {
+    return goTypeName(node.childForFieldName?.("type") || node.childForFieldName?.("operand") || node.namedChildren?.[0]);
+  }
+  if ((node.namedChildren?.length || 0) === 1) return goTypeName(node.namedChildren[0]);
+  return null;
+}
+
+const namedFieldChildren = (node, name) => {
+  const children = node?.childrenForFieldName?.(name);
+  if (Array.isArray(children) && children.length) return children;
+  const child = node?.childForFieldName?.(name);
+  return child ? [child] : [];
+};
+
+function goStructFields(typeNode) {
+  if (typeNode?.type !== "struct_type") return null;
+  const fields = {};
+  const visit = (node) => {
+    if (!node) return;
+    if (node.type === "field_declaration") {
+      const type = goTypeName(node.childForFieldName?.("type"));
+      if (!type) return;
+      const names = namedFieldChildren(node, "name");
+      if (names.length) for (const name of names) fields[name.text] = type;
+      else {
+        // An embedded field is addressed by the base type name (`h.Speaker`).
+        const embedded = type.split(".").pop();
+        if (embedded) fields[embedded] = type;
+      }
+      return;
+    }
+    for (const child of node.namedChildren || []) visit(child);
+  };
+  visit(typeNode);
+  return fields;
+}
+
+function goResultType(declaration) {
+  const result = declaration?.childForFieldName?.("result");
+  if (!result) return null;
+  if (result.type !== "parameter_list") return goTypeName(result);
+  const declarations = (result.namedChildren || []).filter((child) => child.type === "parameter_declaration");
+  // A call used in `value, err := New()` contributes its first result to the
+  // first binding. Preserve that receiver type instead of discarding every
+  // multi-result signature just because a trailing error is present.
+  return goTypeName(declarations[0]?.childForFieldName?.("type"));
+}
+
 export default {
   family: "go",
   grammars: ["go"],
@@ -20,10 +75,40 @@ export default {
     const { grammar, tree, fileRel, caps, addSym, addImportEdge, addExternalImport, imports, resolveGoImport, dirFiles, goModule, goRequires } = ctx;
 
     // ---- symbols ----
-    for (const cap of caps(grammar, `(function_declaration name: (identifier) @fn) (method_declaration name: (field_identifier) @method)`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, true, { sourceNode: cap.node.parent });
-    for (const cap of caps(grammar, `(source_file (type_declaration (type_spec name: (type_identifier) @type)))`, tree.rootNode))
-      addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
+    for (const cap of caps(grammar, `(function_declaration name: (identifier) @fn)`, tree.rootNode)) {
+      const declaration = cap.node.parent;
+      addSym(cap.node.text, cap.node.startPosition.row + 1, true, {
+        sourceNode: declaration,
+        selectionNode: cap.node,
+        symbolKind: "function",
+        returnType: goResultType(declaration),
+      });
+    }
+    for (const cap of caps(grammar, `(method_declaration name: (field_identifier) @method)`, tree.rootNode)) {
+      const declaration = cap.node.parent;
+      const receiver = declaration.childForFieldName?.("receiver");
+      const receiverDeclaration = receiver?.namedChildren?.find((child) => child.type === "parameter_declaration");
+      const receiverType = goTypeName(receiverDeclaration?.childForFieldName?.("type"));
+      addSym(cap.node.text, cap.node.startPosition.row + 1, true, {
+        sourceNode: declaration,
+        selectionNode: cap.node,
+        symbolKind: "method",
+        memberOf: receiverType || undefined,
+        receiverType: receiverType || undefined,
+        returnType: goResultType(declaration),
+      });
+    }
+    for (const cap of caps(grammar, `(source_file (type_declaration (type_spec name: (type_identifier) @type)))`, tree.rootNode)) {
+      const specification = cap.node.parent;
+      const typeNode = specification.childForFieldName?.("type");
+      addSym(cap.node.text, cap.node.startPosition.row + 1, false, {
+        sourceNode: specification,
+        selectionNode: cap.node,
+        symbolKind: typeNode?.type === "interface_type" ? "interface" : "type",
+        symbolSpace: "type",
+        fieldTypes: goStructFields(typeNode),
+      });
+    }
     for (const cap of caps(grammar, `(source_file (var_declaration (var_spec name: (identifier) @var))) (source_file (const_declaration (const_spec name: (identifier) @const)))`, tree.rootNode))
       addSym(cap.node.text, cap.node.startPosition.row + 1, false, { sourceNode: cap.node.parent });
 

package/src/graph/builder/lang-js.js

@@ -2,33 +2,10 @@
 // Symbols: functions, generators, classes, methods, top-level const/let/var (data + arrow/fn consts).
 // Imports: ESM `import`, CJS `require`, path-aliases (tsconfig/vite), and barrel re-exports (`export … from`).
 // Calls: bare `foo()`. Heritage: `class X extends Y`. Everything runs through the shared ctx (see internal-builder.js).
-const CALLABLE = /arrow_function|function|function_expression|generator_function/;
-
-const FUNCS = `
-  (function_declaration name: (identifier) @fn)
-  (generator_function_declaration name: (identifier) @fn)
-  (class_declaration name: (_) @class)
-  (method_definition name: (_) @method)`;
-const TOPVARS = `
-  (program (lexical_declaration (variable_declarator) @decl))
-  (program (variable_declaration (variable_declarator) @decl))
-  (program (export_statement (lexical_declaration (variable_declarator) @decl)))
-  (program (export_statement (variable_declaration (variable_declarator) @decl)))`;
-const TYPES = `
-  (interface_declaration name: (_) @interface)
-  (type_alias_declaration name: (_) @type)
-  (enum_declaration name: (_) @enum)`;
-const REQUIRE = `(variable_declarator name: (_) @lhs value: (call_expression function: (identifier) @req arguments: (arguments (string (string_fragment) @src))))`;
-
-function parseExportSpecifiers(raw) {
-  return String(raw || "").split(",").map((part) => {
-    const text = part.trim();
-    const typeOnly = /^type\s+/.test(text);
-    const clean = text.replace(/^type\s+/, "").trim();
-    const match = clean.match(/^([A-Za-z_$][\w$]*|default)(?:\s+as\s+([A-Za-z_$][\w$]*|default))?$/);
-    return match ? { imported: match[1], exported: match[2] || match[1], typeOnly } : null;
-  }).filter(Boolean);
-}
+import {
+  CALLABLE, FUNCS, TOPVARS, TYPES, REQUIRE, parseExportSpecifiers,
+  importTypeOnly, reexportTypeOnly,
+} from './js/queries.js';
 
 export default {
   family: "js",
@@ -162,23 +139,6 @@ export default {
       });
     }
 
-    const importTypeOnly = (node) => {
-      if (/^\s*import\s+type\b/.test(node.text)) return true;
-      const clause = node.namedChildren.find((c) => c.type === "import_clause");
-      if (!clause) return false; // side-effect import executes the target module
-      const parts = clause.namedChildren;
-      if (parts.some((c) => c.type === "identifier" || c.type === "namespace_import")) return false;
-      const named = parts.find((c) => c.type === "named_imports");
-      const specs = named?.namedChildren.filter((c) => c.type === "import_specifier") || [];
-      return specs.length > 0 && specs.every((s) => /^\s*type\b/.test(s.text));
-    };
-    const reexportTypeOnly = (node) => {
-      if (/^\s*export\s+type\b/.test(node.text)) return true;
-      const clause = node.namedChildren.find((c) => c.type === "export_clause");
-      const specs = clause?.namedChildren.filter((c) => c.type === "export_specifier") || [];
-      return specs.length > 0 && specs.every((s) => /^\s*type\b/.test(s.text));
-    };
-
     // ---- ESM imports ----
     for (const cap of caps(grammar, `(import_statement) @imp`, tree.rootNode)) {
       const node = cap.node; const srcNode = field(node, "source");

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

@@ -0,0 +1,68 @@
+export function createPass2Resolution({symIdsByFileName, nodeById, importedLocals, symByFileName}) {
+    const dirSymbols = new Map(), dirMethods = new Map(), dirMethodsByName = new Map(), dirTypes = new Map()
+    const sharesDirScope = (file) => file.endsWith('.go') || file.endsWith('.cs') || file.endsWith('.rs')
+    for (const [file, names] of symIdsByFileName) {
+        if (!sharesDirScope(file)) continue
+        const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
+        let symbols = dirSymbols.get(dir)
+        if (!symbols) dirSymbols.set(dir, (symbols = new Map()))
+        for (const [name, ids] of names) for (const id of ids) {
+            const node = nodeById.get(id)
+            if (file.endsWith('.go') && node?.member_of && node?.symbol_kind === 'method') {
+                let receivers = dirMethods.get(dir)
+                if (!receivers) dirMethods.set(dir, (receivers = new Map()))
+                let methods = receivers.get(node.member_of)
+                if (!methods) receivers.set(node.member_of, (methods = new Map()))
+                const exact = methods.get(name) || []
+                exact.push(id); methods.set(name, exact)
+                let byName = dirMethodsByName.get(dir)
+                if (!byName) dirMethodsByName.set(dir, (byName = new Map()))
+                const candidates = byName.get(name) || []
+                candidates.push(id); byName.set(name, candidates)
+                continue
+            }
+            if (!symbols.has(name)) symbols.set(name, id)
+            if (file.endsWith('.go') && node?.symbol_space === 'type') {
+                let types = dirTypes.get(dir)
+                if (!types) dirTypes.set(dir, (types = new Map()))
+                if (!types.has(name)) types.set(name, id)
+            }
+        }
+    }
+    const symbolSpace = (node) => {
+        const explicit = String(node?.symbol_space || '')
+        if (['value', 'type', 'both'].includes(explicit)) return explicit
+        const kind = String(node?.symbol_kind || '').toLowerCase()
+        if (['interface', 'type'].includes(kind)) return 'type'
+        return ['class', 'enum'].includes(kind) ? 'both' : 'value'
+    }
+    const resolveNamedSymbol = (file, name, space = 'value') => {
+        const ids = symIdsByFileName.get(file)?.get(name) || []
+        const exact = ids.find((id) => symbolSpace(nodeById.get(id)) === space)
+        return exact || ids.find((id) => ['both', space].includes(symbolSpace(nodeById.get(id)))) || null
+    }
+    const resolveCall = (name, file) => {
+        const local = resolveNamedSymbol(file, name, 'value')
+        if (local) return local
+        if (sharesDirScope(file)) {
+            const dir = file.includes('/') ? file.slice(0, file.lastIndexOf('/')) : ''
+            const symbols = dirSymbols.get(dir)
+            if (symbols?.has(name)) return symbols.get(name)
+        }
+        const imported = importedLocals.get(file)?.get(name)
+        if (!imported?.targetFile) return null
+        return resolveNamedSymbol(imported.originFile || imported.targetFile, imported.originName || imported.imported, 'value')
+    }
+    const javaTypeKinds = new Set(['class', 'interface', 'enum', 'record', 'annotation'])
+    const resolveJavaType = (name, file) => {
+        const imported = importedLocals.get(file)?.get(name)
+        if (imported?.targetFile) {
+            const symbols = symByFileName.get(imported.targetFile)
+            const target = symbols?.get(imported.imported) || symbols?.get(name)
+            if (target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind)) return target
+        }
+        const target = symByFileName.get(file)?.get(name)
+        return target && javaTypeKinds.has(nodeById.get(target)?.symbol_kind) ? target : null
+    }
+    return {dirSymbols, dirMethods, dirMethodsByName, dirTypes, resolveNamedSymbol, resolveCall, resolveJavaType}
+}

package/src/graph/freshness-probe.js

@@ -9,7 +9,7 @@ import {childProcessEnv} from '../child-env.js'
 import {createRepoBoundary} from '../repo-path.js'
 
 export const REPOSITORY_FRESHNESS_PROBE_V = 1
-export const GRAPH_BUILDER_SCHEMA_V = 5
+export const GRAPH_BUILDER_SCHEMA_V = 6
 export const GRAPH_BUILDER_VERSION = (() => {
     try { return String(createRequire(import.meta.url)('../../package.json').version) }
     catch { return '0.0.0' }
@@ -23,6 +23,7 @@ const CURRENT_GRAPH_SCHEMA = Object.freeze({
     edgeTypesV: 2,
     edgeProvenanceV: 1,
     complexityV: 2,
+    physicalFileLocV: 1,
     repoBoundaryV: 1,
     barrelResolutionV: 1,
     reExportOccurrencesV: 1,

package/src/graph/incremental-refresh.js

@@ -163,7 +163,7 @@ function mergeScopedGraph(base, scoped, affected, snapshot) {
     controlHashes: snapshot.controlHashes,
     graphRevision: snapshot.revision,
   };
-  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "repoBoundaryV", "barrelResolutionV", "reExportOccurrencesV", "symbolSpacesV", "extractorSchemaV"]) {
+  for (const key of ["extImportsV", "edgeTypesV", "edgeProvenanceV", "complexityV", "physicalFileLocV", "repoBoundaryV", "barrelResolutionV", "reExportOccurrencesV", "symbolSpacesV", "extractorSchemaV"]) {
     merged[key] = Math.max(Number(base[key]) || 0, Number(scoped[key]) || 0);
   }
   return merged;
@@ -184,7 +184,8 @@ export async function refreshGraphIncrementally(repoDir, existingGraph, {
 
   if (!existingGraph || !existingGraph.fileHashes || !existingGraph.fileExportSignatures
     || !existingGraph.controlHashes || !existingGraph.jsExportRecords || Number(existingGraph.barrelResolutionV) < 1
-    || Number(existingGraph.extractorSchemaV) < 5 || Number(existingGraph.reExportOccurrencesV) < 1
+    || Number(existingGraph.extractorSchemaV) < 5 || Number(existingGraph.physicalFileLocV) < 1
+    || Number(existingGraph.reExportOccurrencesV) < 1
     || Number(existingGraph.symbolSpacesV) < 1 || Number(existingGraph.edgeProvenanceV) < 1) {
     return full("incremental-baseline-unavailable");
   }