@snevins/repo-mapper 1.5.2 → 1.5.3

package/dist/graph.d.ts

@@ -9,6 +9,12 @@ export declare function computeFileDegrees(graph: FileGraph): Map<string, FileDe
 /**
  * Build file reference graph from parsed tags.
  * Nodes are files, edges are symbol references from one file to another.
+ *
+ * Scoped definitions: When a definition has a parent scope (e.g., a function
+ * inside a contract/class), edges are only created if the referencing file
+ * also references the parent scope. This prevents spurious edges from name
+ * collisions (e.g., multiple contracts defining `bid()` won't all get edges
+ * from every file that references any `bid()`).
  */
 export declare function buildFileGraph(tags: readonly Tag[], options?: GraphBuildOptions): FileGraph;
 /**
@@ -18,5 +24,8 @@ export declare function buildFileGraph(tags: readonly Tag[], options?: GraphBuil
  * Unlike buildFileGraph which uses ref counts, this assigns weight 1
  * to each unique file-to-file import relationship regardless of how
  * many times symbols are referenced.
+ *
+ * Uses same scoped definition logic as buildFileGraph to prevent spurious
+ * edges from name collisions.
  */
 export declare function buildImportGraph(tags: readonly Tag[], options?: GraphBuildOptions): FileGraph;

package/dist/graph.js

@@ -47,12 +47,20 @@ export function computeFileDegrees(graph) {
 /**
  * Build file reference graph from parsed tags.
  * Nodes are files, edges are symbol references from one file to another.
+ *
+ * Scoped definitions: When a definition has a parent scope (e.g., a function
+ * inside a contract/class), edges are only created if the referencing file
+ * also references the parent scope. This prevents spurious edges from name
+ * collisions (e.g., multiple contracts defining `bid()` won't all get edges
+ * from every file that references any `bid()`).
  */
 export function buildFileGraph(tags, options) {
     const getMultiplier = options?.edgeWeightMultiplier ?? (() => 1.0);
-    // First pass: collect nodes and index defs
+    // First pass: collect nodes, index defs, and track refs per file
     const nodeSet = new Set();
     const defsByName = new Map();
+    // Track all symbol names referenced by each file (for parent scope checking)
+    const refsByFile = new Map();
     for (const tag of tags) {
         nodeSet.add(tag.relPath);
         if (tag.kind === "def") {
@@ -64,6 +72,15 @@ export function buildFileGraph(tags, options) {
                 defsByName.set(tag.name, [tag]);
             }
         }
+        else {
+            // kind === "ref": Track all refs per file for parent scope checking
+            let fileRefs = refsByFile.get(tag.relPath);
+            if (!fileRefs) {
+                fileRefs = new Set();
+                refsByFile.set(tag.relPath, fileRefs);
+            }
+            fileRefs.add(tag.name);
+        }
     }
     // Sort nodes for determinism
     const nodes = [...nodeSet].sort();
@@ -79,10 +96,19 @@ export function buildFileGraph(tags, options) {
         const defs = defsByName.get(tag.name);
         if (!defs)
             continue;
+        // Get refs for this file (for parent scope checking)
+        const fileRefs = refsByFile.get(tag.relPath);
         for (const def of defs) {
             // Skip self-edges
             if (def.relPath === tag.relPath)
                 continue;
+            // Scoped definition check: if the definition has a parent scope,
+            // only create edge if the referencing file also references the parent.
+            // This prevents spurious edges from name collisions across unrelated
+            // contracts/classes (e.g., multiple contracts with `bid()` function).
+            if (def.parent && (!fileRefs || !fileRefs.has(def.parent))) {
+                continue;
+            }
             const from = tag.relPath;
             const to = def.relPath;
             const symbol = tag.name;
@@ -167,12 +193,17 @@ export function buildFileGraph(tags, options) {
  * Unlike buildFileGraph which uses ref counts, this assigns weight 1
  * to each unique file-to-file import relationship regardless of how
  * many times symbols are referenced.
+ *
+ * Uses same scoped definition logic as buildFileGraph to prevent spurious
+ * edges from name collisions.
  */
 export function buildImportGraph(tags, options) {
     const getMultiplier = options?.edgeWeightMultiplier ?? (() => 1.0);
-    // First pass: collect nodes and index defs
+    // First pass: collect nodes, index defs, and track refs per file
     const nodeSet = new Set();
     const defsByName = new Map();
+    // Track all symbol names referenced by each file (for parent scope checking)
+    const refsByFile = new Map();
     for (const tag of tags) {
         nodeSet.add(tag.relPath);
         if (tag.kind === "def") {
@@ -184,6 +215,15 @@ export function buildImportGraph(tags, options) {
                 defsByName.set(tag.name, [tag]);
             }
         }
+        else {
+            // kind === "ref": Track all refs per file for parent scope checking
+            let fileRefs = refsByFile.get(tag.relPath);
+            if (!fileRefs) {
+                fileRefs = new Set();
+                refsByFile.set(tag.relPath, fileRefs);
+            }
+            fileRefs.add(tag.name);
+        }
     }
     const nodes = [...nodeSet].sort();
     // Second pass: build binary edges (1 per unique file→file connection)
@@ -197,9 +237,16 @@ export function buildImportGraph(tags, options) {
         const defs = defsByName.get(tag.name);
         if (!defs)
             continue;
+        // Get refs for this file (for parent scope checking)
+        const fileRefs = refsByFile.get(tag.relPath);
         for (const def of defs) {
             if (def.relPath === tag.relPath)
                 continue;
+            // Scoped definition check: if the definition has a parent scope,
+            // only create edge if the referencing file also references the parent.
+            if (def.parent && (!fileRefs || !fileRefs.has(def.parent))) {
+                continue;
+            }
             const from = tag.relPath;
             const to = def.relPath;
             // Check if we already have this edge (binary: only count once)

package/dist/output.js

@@ -83,22 +83,6 @@ function formatRankDisplay(rank, sortedRanks) {
     const percentile = computePercentile(rank, sortedRanks);
     return (percentile / 100).toFixed(1);
 }
-/**
- * Get all definition tags for a specific file from the graph.
- * Used to show all definitions for files that are included in output,
- * not just the ones that were cross-file referenced.
- */
-function getAllDefsForFile(file, graph) {
-    const result = [];
-    for (const tags of graph.defsByName.values()) {
-        for (const tag of tags) {
-            if (tag.relPath === file) {
-                result.push(tag);
-            }
-        }
-    }
-    return result;
-}
 /**
  * Resolve RankedDefinitions to their Tags by looking up in graph.defsByName.
  * Returns only definitions that can be found.
@@ -246,18 +230,17 @@ export function formatOutput(defs, graph, fileRanks, focusFiles, maxFilesPerModu
         lines.push(`## ${mod}${suffix} (${String(modFiles.length)} file${modFiles.length > 1 ? "s" : ""})`);
         // Files in this module (already sorted by rank)
         for (const file of modFiles) {
-            // Get ALL definitions for the file, not just cross-file referenced ones
-            const allFileTags = getAllDefsForFile(file, graph);
-            if (allFileTags.length === 0)
+            const fileDefs = fileGroups.get(file);
+            if (!fileDefs || fileDefs.length === 0)
                 continue;
             const fileRank = fileRanks.get(file) ?? 0;
             const deps = getFileDependents(file, graph);
             const depsStr = deps.length > 0 ? ` (used-by: ${deps.slice(0, 10).join(", ")}${deps.length > 10 ? ", ..." : ""})` : "";
             lines.push(`${file}: ${formatRankDisplay(fileRank, allRanks)}${depsStr}`);
             // Sort definitions by line ascending
-            const sorted = [...allFileTags].sort((a, b) => a.line - b.line);
-            for (const tag of sorted) {
-                lines.push(`  ${tag.signature ?? tag.name}`);
+            const sorted = [...fileDefs].sort((a, b) => a.tag.line - b.tag.line);
+            for (const def of sorted) {
+                lines.push(`  ${def.tag.signature ?? def.tag.name}`);
             }
         }
         // Omission annotation if files were limited

package/dist/parser.js

@@ -75,6 +75,36 @@ const EXPORT_BLOCKERS = new Set([
     "class",
     "class_expression",
 ]);
+/**
+ * Node types that establish a parent scope for member definitions.
+ * Used to track which contract/class/interface a function/struct belongs to.
+ * This prevents spurious edges from name collisions across unrelated scopes.
+ */
+const PARENT_SCOPE_TYPES = {
+    solidity: new Set(["contract_declaration", "interface_declaration", "library_declaration"]),
+    typescript: new Set(["class_declaration", "abstract_class_declaration"]),
+    tsx: new Set(["class_declaration", "abstract_class_declaration"]),
+    javascript: new Set(["class_declaration"]),
+    jsx: new Set(["class_declaration"]),
+    python: new Set(["class_definition"]),
+    rust: new Set(["impl_item", "trait_item"]),
+    go: new Set(), // Go uses package-level scope, no class-like containers
+};
+/**
+ * Get the name of a parent scope node (contract/class/interface name).
+ */
+function getParentScopeName(node) {
+    const nameNode = node.childForFieldName("name");
+    if (nameNode)
+        return nameNode.text;
+    // For Rust impl blocks: impl Foo { ... } or impl Trait for Foo { ... }
+    if (node.type === "impl_item") {
+        const typeNode = node.childForFieldName("type");
+        if (typeNode?.type === "type_identifier")
+            return typeNode.text;
+    }
+    return undefined;
+}
 /**
  * Check if a variable_declarator is directly exported (not inside a function/class).
  * Stops at function/class boundaries to prevent local variables from being captured.
@@ -266,13 +296,18 @@ export async function parseFile(absPath, relPath) {
     // Walk tree to extract definitions and references
     const cursor = tree.walk();
     const visitedNodes = new Set();
-    function walk() {
+    // Get parent scope types for this language
+    const parentScopeTypes = PARENT_SCOPE_TYPES[langConfig.grammarName] ?? new Set();
+    function walk(currentParent) {
         const node = cursor.currentNode;
         const nodeId = node.id;
         // Avoid visiting same node twice
         if (visitedNodes.has(nodeId))
             return;
         visitedNodes.add(nodeId);
+        // Check if this node establishes a new parent scope
+        const isParentScope = parentScopeTypes.has(node.type);
+        const newParent = isParentScope ? getParentScopeName(node) : currentParent;
         // Check for definition nodes using config's definition types
         if (langConfig.definitionTypes.has(node.type)) {
             if (shouldIncludeDefinition(node, langConfig)) {
@@ -294,6 +329,9 @@ export async function parseFile(absPath, relPath) {
                         // For Python/Go/Rust/Solidity: all captured defs are "exported" (public API)
                         nodeIsExported = true;
                     }
+                    // For parent scope definitions (contract/class), don't set parent
+                    // (they ARE the parent, not children of another scope)
+                    const defParent = isParentScope ? undefined : currentParent;
                     tags.push({
                         relPath,
                         absPath,
@@ -302,6 +340,7 @@ export async function parseFile(absPath, relPath) {
                         kind: "def",
                         signature: getSignature(node, sourceLines),
                         isExported: nodeIsExported,
+                        parent: defParent,
                     });
                 }
             }
@@ -318,6 +357,7 @@ export async function parseFile(absPath, relPath) {
                     kind: "def",
                     signature: getSignature(node, sourceLines),
                     isExported: true, // isDirectlyExportedVariable already checks this
+                    parent: currentParent,
                 });
             }
         }
@@ -334,10 +374,10 @@ export async function parseFile(absPath, relPath) {
                 });
             }
         }
-        // Recurse into children
+        // Recurse into children with updated parent scope
         if (cursor.gotoFirstChild()) {
             do {
-                walk();
+                walk(newParent);
             } while (cursor.gotoNextSibling());
             cursor.gotoParent();
         }

package/dist/types.d.ts

@@ -10,6 +10,11 @@ export interface Tag {
     readonly signature?: string;
     /** Whether this definition is exported (public API). Only set for "def" kind. */
     readonly isExported?: boolean;
+    /**
+     * Parent scope for member definitions (e.g., "ReserveAuction" for a function inside that contract).
+     * Used to prevent spurious edges from name collisions across unrelated contracts/classes.
+     */
+    readonly parent?: string;
 }
 /**
  * CLI options parsed from command line arguments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@snevins/repo-mapper",
-  "version": "1.5.2",
+  "version": "1.5.3",
   "description": "Generate token-budgeted repo maps for LLM context using tree-sitter and PageRank",
   "type": "module",
   "main": "dist/index.js",