@snevins/repo-mapper 1.0.3 → 1.2.0

package/README.md

@@ -9,6 +9,7 @@ Generate token-budgeted maps of code repositories for LLM context. Uses tree-sit
 
 - **Token budgeting**: Fit the most important code into your context window
 - **Smart ranking**: PageRank algorithm prioritizes frequently-referenced code
+- **Module clustering**: Groups files by directory with global top-50 guarantee
 - **Focus mode**: Bias output toward files you're working on
 - **Fast caching**: Only re-parses changed files
 
@@ -44,12 +45,14 @@ repo-mapper [paths...] [options]
 
 | Option | Default | Description |
 |--------|---------|-------------|
-| `-t, --tokens <n>` | 1024 | Maximum tokens for output |
+| `-t, --tokens <n>` | 4000 | Maximum tokens for output |
 | `-f, --focus <file>` | | Files to prioritize (repeatable) |
 | `-o, --output <file>` | stdout | Write output to file |
 | `-r, --refresh` | false | Ignore cache, re-parse all |
 | `-v, --verbose` | false | Print progress info |
+| `--type <lang>` | | Filter by language: ts, js, python, go, rust, solidity (repeatable) |
 | `--ignore <pattern>` | | Additional ignore patterns (repeatable) |
+| `--include <pattern>` | | Only include files matching pattern (repeatable) |
 | `--no-ignore` | false | Disable default ignores |
 | `--max-files <n>` | 10000 | Maximum files to process |
 
@@ -62,6 +65,12 @@ repo-mapper . -t 2000
 # Focus on specific files you're editing
 repo-mapper . -f src/api.ts -f src/types.ts -t 4000
 
+# Only TypeScript files
+repo-mapper . --type ts -t 2000
+
+# Only Rust files in a mixed repo
+repo-mapper . --type rust -t 2000
+
 # Save to file for LLM prompt
 repo-mapper . -t 8000 -o context.md
 
@@ -86,9 +95,9 @@ src/pagerank.ts:
 
 ## Caching
 
-Cache is stored in `.repomap.cache.v1/` in the repository root. Files are re-parsed only when modified (mtime-based invalidation).
+Cache is stored in `.repomap.cache.v2/` in the repository root. Files are re-parsed only when modified (mtime-based invalidation).
 
-Clear cache with: `rm -rf .repomap.cache.v1`
+Clear cache with: `rm -rf .repomap.cache.v2`
 
 ## How It Works
 
@@ -98,6 +107,28 @@ Clear cache with: `rm -rf .repomap.cache.v1`
 4. **Rank** - Run PageRank to score files by importance
 5. **Budget** - Binary search to fit top definitions within token limit
 
+## Claude Code Plugin
+
+repo-mapper includes a Claude Code plugin with commands and skills.
+
+### Installation
+
+```bash
+# Add to your Claude Code plugins
+claude plugins add /path/to/repo-mapper-ts
+```
+
+### Commands
+
+| Command | Description |
+|---------|-------------|
+| `/status` | Check if repo-mapper is installed and up to date |
+| `/update-codemap` | Generate or update CODEMAP.md with smart language detection |
+
+### Skills
+
+The `using-repo-mapper` skill provides guidance on effective repo-mapper usage patterns.
+
 ## License
 
 MIT

package/dist/cli.d.ts

@@ -1,6 +1,22 @@
 import type { ParsedArgs } from "./types.js";
+/**
+ * Error thrown when --help or -h is requested.
+ * Main should catch this, print usage, and exit(0).
+ */
+export declare class HelpRequestedError extends Error {
+    constructor();
+}
+/**
+ * Error thrown when --version or -V is requested.
+ * Main should catch this, print version, and exit(0).
+ */
+export declare class VersionRequestedError extends Error {
+    constructor();
+}
 /**
  * Parse CLI arguments into structured format.
+ * Throws HelpRequestedError if --help or -h is present.
+ * Throws VersionRequestedError if --version or -V is present.
  * Throws on invalid input.
  */
 export declare function parseCliArgs(argv: readonly string[]): ParsedArgs;

package/dist/cli.js

@@ -1,11 +1,41 @@
 import { parseArgs } from "node:util";
-const DEFAULT_TOKENS = 1024;
+const DEFAULT_TOKENS = 4000;
 const DEFAULT_MAX_FILES = 10000;
+/**
+ * Error thrown when --help or -h is requested.
+ * Main should catch this, print usage, and exit(0).
+ */
+export class HelpRequestedError extends Error {
+    constructor() {
+        super("Help requested");
+        this.name = "HelpRequestedError";
+    }
+}
+/**
+ * Error thrown when --version or -V is requested.
+ * Main should catch this, print version, and exit(0).
+ */
+export class VersionRequestedError extends Error {
+    constructor() {
+        super("Version requested");
+        this.name = "VersionRequestedError";
+    }
+}
 /**
  * Parse CLI arguments into structured format.
+ * Throws HelpRequestedError if --help or -h is present.
+ * Throws VersionRequestedError if --version or -V is present.
  * Throws on invalid input.
  */
 export function parseCliArgs(argv) {
+    // Check for --help or -h BEFORE calling parseArgs (which would throw on unknown flags)
+    if (argv.includes("--help") || argv.includes("-h")) {
+        throw new HelpRequestedError();
+    }
+    // Check for --version or -V BEFORE calling parseArgs
+    if (argv.includes("--version") || argv.includes("-V")) {
+        throw new VersionRequestedError();
+    }
     const { values, positionals } = parseArgs({
         args: argv,
         options: {
@@ -15,8 +45,10 @@ export function parseCliArgs(argv) {
             refresh: { type: "boolean", short: "r" },
             verbose: { type: "boolean", short: "v" },
             ignore: { type: "string", multiple: true },
+            include: { type: "string", multiple: true },
             "no-ignore": { type: "boolean" },
             "max-files": { type: "string" },
+            type: { type: "string", multiple: true },
         },
         allowPositionals: true,
         strict: true,
@@ -32,8 +64,10 @@ export function parseCliArgs(argv) {
             refresh: values.refresh ?? false,
             verbose: values.verbose ?? false,
             ignore: values.ignore ?? [],
+            include: values.include ?? [],
             noIgnore: values["no-ignore"] ?? false,
             maxFiles,
+            type: values.type ?? [],
         },
     };
 }

package/dist/dedup.d.ts

@@ -0,0 +1,27 @@
+import type { Tag } from "./types.js";
+/**
+ * A group of files that appear to be duplicates based on their definition names.
+ */
+export interface DuplicateGroup {
+    readonly fingerprint: string;
+    readonly files: readonly string[];
+    /** First alphabetically - the "canonical" version to keep */
+    readonly canonical: string;
+}
+/**
+ * Compute a fingerprint for a file based on its definition names.
+ * Files with the same fingerprint likely contain copy-pasted code.
+ */
+export declare function computeFingerprint(tags: readonly Tag[]): string;
+/**
+ * Detect duplicate files based on their definition fingerprints.
+ * Returns a map from file path to its duplicate group info.
+ */
+export declare function detectDuplicates(tagsByFile: ReadonlyMap<string, readonly Tag[]>): Map<string, DuplicateGroup>;
+/**
+ * Get the ranking penalty for a file based on duplicate status.
+ * - Canonical file: 1.0 (no penalty)
+ * - Non-canonical duplicate: 0.3 (70% penalty)
+ * - Non-duplicate: 1.0 (no penalty)
+ */
+export declare function getDuplicatePenalty(file: string, duplicates: ReadonlyMap<string, DuplicateGroup>): number;

package/dist/dedup.js

@@ -0,0 +1,67 @@
+import { createHash } from "node:crypto";
+/**
+ * Compute a fingerprint for a file based on its definition names.
+ * Files with the same fingerprint likely contain copy-pasted code.
+ */
+export function computeFingerprint(tags) {
+    const names = tags
+        .filter((t) => t.kind === "def")
+        .map((t) => t.name)
+        .sort();
+    return createHash("sha256")
+        .update(names.join("\0"))
+        .digest("hex")
+        .slice(0, 16);
+}
+/**
+ * Detect duplicate files based on their definition fingerprints.
+ * Returns a map from file path to its duplicate group info.
+ */
+export function detectDuplicates(tagsByFile) {
+    // Group files by fingerprint
+    const byFingerprint = new Map();
+    for (const [file, tags] of tagsByFile) {
+        // Skip tiny files - not enough signal to detect duplicates
+        const defs = tags.filter((t) => t.kind === "def");
+        if (defs.length < 3)
+            continue;
+        const fp = computeFingerprint(tags);
+        const group = byFingerprint.get(fp) ?? [];
+        group.push(file);
+        byFingerprint.set(fp, group);
+    }
+    // Build result map - only include actual duplicates (2+ files)
+    const result = new Map();
+    for (const [fp, files] of byFingerprint) {
+        if (files.length < 2)
+            continue;
+        // Sort for determinism, first becomes canonical
+        const sorted = [...files].sort();
+        const firstFile = sorted[0];
+        if (!firstFile)
+            continue; // Defensive - can't happen due to length check above
+        const canonical = firstFile;
+        const group = {
+            fingerprint: fp,
+            files: sorted,
+            canonical,
+        };
+        // Map each file to the group
+        for (const file of sorted) {
+            result.set(file, group);
+        }
+    }
+    return result;
+}
+/**
+ * Get the ranking penalty for a file based on duplicate status.
+ * - Canonical file: 1.0 (no penalty)
+ * - Non-canonical duplicate: 0.3 (70% penalty)
+ * - Non-duplicate: 1.0 (no penalty)
+ */
+export function getDuplicatePenalty(file, duplicates) {
+    const group = duplicates.get(file);
+    if (!group)
+        return 1.0;
+    return group.canonical === file ? 1.0 : 0.3;
+}

package/dist/files.d.ts

@@ -1,4 +1,9 @@
 import type { FileDiscoveryOptions, FileDiscoveryResult } from "./types.js";
+/**
+ * Check if a path indicates a test or script file.
+ * Used for soft-ignore (downweight edges from these files).
+ */
+export declare function isTestOrScriptPath(relPath: string): boolean;
 /**
  * Directories always skipped during discovery.
  */

package/dist/files.js

@@ -2,6 +2,39 @@ import { readdir, readFile } from "node:fs/promises";
 import { join, extname, resolve, relative } from "node:path";
 import ignore from "ignore";
 import { LANGUAGE_REGISTRY } from "./languages.js";
+/**
+ * Patterns that indicate test/script files (for soft-ignore weighting).
+ * Files matching these patterns get downweighted in the graph, not excluded.
+ */
+const TEST_SCRIPT_PATTERNS = [
+    // Test directories (at start or after /)
+    /(^|[/\\])test[/\\]/,
+    /(^|[/\\])tests[/\\]/,
+    /(^|[/\\])testing[/\\]/,
+    /(^|[/\\])__tests__[/\\]/,
+    /(^|[/\\])spec[/\\]/,
+    // Test utility files (anywhere in path)
+    /testutil/,
+    /test_helper/,
+    /test_utils/,
+    // Test file naming patterns
+    /_test\.(ts|js|py|go|rs)$/,
+    /\.test\.(ts|js)$/,
+    /\.spec\.(ts|js)$/,
+    /(^|[/\\])test_[^/\\]*\.py$/, // test_*.py
+    // Script/tool directories (at start or after /)
+    /(^|[/\\])scripts?[/\\]/,
+    /(^|[/\\])tools?[/\\]/,
+    /(^|[/\\])examples?[/\\]/,
+    /(^|[/\\])benchmarks?[/\\]/,
+];
+/**
+ * Check if a path indicates a test or script file.
+ * Used for soft-ignore (downweight edges from these files).
+ */
+export function isTestOrScriptPath(relPath) {
+    return TEST_SCRIPT_PATTERNS.some((p) => p.test(relPath));
+}
 /**
  * Directories always skipped during discovery.
  */
@@ -29,6 +62,15 @@ export const DEFAULT_IGNORED_DIRS = new Set([
     ".cache",
     "vendor",
     "third_party",
+    "compiled",
+    "examples",
+    "test",
+    "tests",
+    "testing",
+    "__tests__",
+    "__testfixtures__",
+    "benches",
+    "benchmarks",
 ]);
 /**
  * Default patterns for files to ignore (generated, tests, mocks).
@@ -58,14 +100,16 @@ export const DEFAULT_IGNORED_PATTERNS = [
     "**/*.spec.tsx",
     "**/*.spec.js",
     "**/*.spec.jsx",
-    "**/__tests__/**",
     // Mocks/fixtures
     "**/__mocks__/**",
-    "**/mocks/**",
-    "**/mock_*/**",
+    "**/mock*/**",
     "**/*_mock.go",
     "**/fixtures/**",
     "**/testdata/**",
+    // Test helpers
+    "**/tests/**/extension/**",
+    "**/test_helpers/**",
+    "**/spec/support/**",
     // Bundled/minified files (Phase 16)
     "**/*.min.js",
     "**/*.min.mjs",
@@ -79,6 +123,50 @@ export const DEFAULT_IGNORED_PATTERNS = [
     "**/vendor*.js",
     "**/runtime*.js",
     "**/edge-runtime/**",
+    // Test utilities
+    "**/*.util.ts",
+    "**/*.util.js",
+    // Test utilities (language-specific)
+    "**/testutil.rs",
+    "**/testutil.go",
+    "**/testutil.ts",
+    "**/testutil.js",
+    "**/testutils.rs",
+    "**/testutils.go",
+    "**/testutils.ts",
+    "**/testutils.js",
+    "**/test_util.py",
+    "**/test_utils.py",
+    "**/*_fake.go",
+    "**/*_fake.rs",
+    // Storybook files
+    "**/*.stories.ts",
+    "**/*.stories.tsx",
+    "**/*.stories.js",
+    "**/*.stories.jsx",
+    "**/*.stories.mdx",
+    "**/*.story.ts",
+    "**/*.story.tsx",
+    "**/*.story.js",
+    "**/*.story.jsx",
+    // Formal verification / test harnesses
+    "**/fv/**",
+    "**/harnesses/**",
+    // Type declaration files (implementation-less)
+    "**/*.d.ts",
+    "**/*.d.mts",
+    "**/*.d.cts",
+    // Template/scaffold directories
+    "**/templates/**",
+    "**/template/**",
+    "**/create-*-app/**",
+    "**/starter/**",
+    "**/boilerplate/**",
+    // Additional generated/internal
+    "**/bundles/**",
+    "**/*.snap",
+    "**/*.map",
+    "**/*compiled*",
 ];
 /**
  * File extensions supported for parsing.
@@ -96,6 +184,7 @@ export async function discoverFiles(options) {
     const extensions = options.extensions ?? SUPPORTED_EXTENSIONS;
     const ignoredDirs = options.ignoredDirs ?? DEFAULT_IGNORED_DIRS;
     const ignoredPatterns = options.ignoredPatterns;
+    const includePatterns = options.includePatterns;
     const respectGitignore = options.respectGitignore ?? true;
     const includeHidden = options.includeHidden ?? false;
     const maxFiles = options.maxFiles;
@@ -112,11 +201,27 @@ export async function discoverFiles(options) {
             throw new Error(`Invalid ignore pattern: ${msg}`);
         }
     }
+    // Compile include pattern matcher (if patterns provided)
+    let includeMatcher;
+    if (includePatterns && includePatterns.length > 0) {
+        try {
+            includeMatcher = ignore().add([...includePatterns]);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            throw new Error(`Invalid include pattern: ${msg}`);
+        }
+    }
     function isIgnoredByPatterns(relPath) {
         if (!patternMatcher)
             return false;
         return patternMatcher.ignores(relPath);
     }
+    function isIncludedByPatterns(relPath) {
+        if (!includeMatcher)
+            return true; // no include patterns = include all
+        return includeMatcher.ignores(relPath); // "ignores" means "matches"
+    }
     async function loadGitignore(dir) {
         if (!respectGitignore)
             return undefined;
@@ -183,6 +288,8 @@ export async function discoverFiles(options) {
                 if (isIgnoredByGitignore(absPath, false))
                     continue;
                 const relPath = relative(rootDir, absPath);
+                if (!isIncludedByPatterns(relPath))
+                    continue;
                 if (isIgnoredByPatterns(relPath))
                     continue;
                 files.push(absPath);

package/dist/graph.d.ts

@@ -1,6 +1,22 @@
-import type { Tag, FileGraph } from "./types.js";
+import type { Tag, FileGraph, GraphBuildOptions, FileDegrees } from "./types.js";
+/**
+ * Compute in-degree, out-degree, and module diversity for each file.
+ * - outDegree: number of unique files this file references
+ * - inDegree: number of unique files that reference this file
+ * - uniqueModulesReferenced: number of unique first-level directories in out-edges
+ */
+export declare function computeFileDegrees(graph: FileGraph): Map<string, FileDegrees>;
 /**
  * Build file reference graph from parsed tags.
  * Nodes are files, edges are symbol references from one file to another.
  */
-export declare function buildFileGraph(tags: readonly Tag[]): FileGraph;
+export declare function buildFileGraph(tags: readonly Tag[], options?: GraphBuildOptions): FileGraph;
+/**
+ * Build import graph with binary edges (1 per file→file relationship).
+ * Captures module structure without reference frequency noise.
+ *
+ * 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.
+ */
+export declare function buildImportGraph(tags: readonly Tag[], options?: GraphBuildOptions): FileGraph;

package/dist/graph.js

@@ -1,8 +1,55 @@
+/**
+ * Get first path segment (module) from a file path.
+ * e.g., "utils/helper.ts" -> "utils", "main.ts" -> ""
+ */
+function getModule(path) {
+    const slash = path.indexOf("/");
+    return slash === -1 ? "" : path.slice(0, slash);
+}
+/**
+ * Compute in-degree, out-degree, and module diversity for each file.
+ * - outDegree: number of unique files this file references
+ * - inDegree: number of unique files that reference this file
+ * - uniqueModulesReferenced: number of unique first-level directories in out-edges
+ */
+export function computeFileDegrees(graph) {
+    const result = new Map();
+    // Initialize all nodes with zero degrees
+    for (const node of graph.nodes) {
+        result.set(node, { inDegree: 0, outDegree: 0, uniqueModulesReferenced: 0 });
+    }
+    // Compute out-degree and in-degree from edges
+    for (const [from, toMap] of graph.edges) {
+        const outDegree = toMap.size;
+        const modules = new Set();
+        for (const to of toMap.keys()) {
+            modules.add(getModule(to));
+            // Increment in-degree for target
+            const targetDegrees = result.get(to);
+            if (targetDegrees) {
+                result.set(to, {
+                    ...targetDegrees,
+                    inDegree: targetDegrees.inDegree + 1,
+                });
+            }
+        }
+        const current = result.get(from);
+        if (current) {
+            result.set(from, {
+                ...current,
+                outDegree,
+                uniqueModulesReferenced: modules.size,
+            });
+        }
+    }
+    return result;
+}
 /**
  * Build file reference graph from parsed tags.
  * Nodes are files, edges are symbol references from one file to another.
  */
-export function buildFileGraph(tags) {
+export function buildFileGraph(tags, options) {
+    const getMultiplier = options?.edgeWeightMultiplier ?? (() => 1.0);
     // First pass: collect nodes and index defs
     const nodeSet = new Set();
     const defsByName = new Map();
@@ -20,8 +67,10 @@ export function buildFileGraph(tags) {
     }
     // Sort nodes for determinism
     const nodes = [...nodeSet].sort();
-    // Second pass: build edges (need defsByName complete first)
-    // Track both file-level and symbol-level edges
+    // Weight multiplier for non-exported symbols (internal helpers rank lower)
+    const NON_EXPORTED_WEIGHT = 0.5;
+    // Second pass: build edges with semantic weighting
+    // Exported symbols get full weight, non-exported get reduced weight
     const edgesBuilder = new Map();
     const symbolEdgesBuilder = new Map();
     for (const tag of tags) {
@@ -37,14 +86,17 @@ export function buildFileGraph(tags) {
             const from = tag.relPath;
             const to = def.relPath;
             const symbol = tag.name;
-            // File-level edge
+            // Semantic weight: exported symbols get full weight, non-exported get reduced
+            // Treat undefined isExported as exported (backwards compatibility)
+            const semanticWeight = def.isExported === false ? NON_EXPORTED_WEIGHT : 1.0;
+            // File-level edge (with semantic weight)
             let fromEdges = edgesBuilder.get(from);
             if (!fromEdges) {
                 fromEdges = new Map();
                 edgesBuilder.set(from, fromEdges);
             }
-            fromEdges.set(to, (fromEdges.get(to) ?? 0) + 1);
-            // Symbol-level edge
+            fromEdges.set(to, (fromEdges.get(to) ?? 0) + semanticWeight);
+            // Symbol-level edge (with semantic weight)
             let fromSymbolEdges = symbolEdgesBuilder.get(from);
             if (!fromSymbolEdges) {
                 fromSymbolEdges = new Map();
@@ -55,10 +107,133 @@ export function buildFileGraph(tags) {
                 toSymbolEdges = new Map();
                 fromSymbolEdges.set(to, toSymbolEdges);
             }
-            toSymbolEdges.set(symbol, (toSymbolEdges.get(symbol) ?? 0) + 1);
+            toSymbolEdges.set(symbol, (toSymbolEdges.get(symbol) ?? 0) + semanticWeight);
+        }
+    }
+    // Compute raw outWeights (before normalization)
+    const rawOutWeights = new Map();
+    for (const [from, toMap] of edgesBuilder) {
+        let total = 0;
+        for (const weight of toMap.values()) {
+            total += weight;
+        }
+        rawOutWeights.set(from, total);
+    }
+    // Normalize edges: divide each edge weight by total outgoing weight
+    // This makes all files have equal influence regardless of reference count
+    // Then apply multiplier to scale file's total influence (test files get less)
+    for (const [from, toMap] of edgesBuilder) {
+        const totalRefs = rawOutWeights.get(from) ?? 1;
+        const multiplier = getMultiplier(from);
+        if (totalRefs > 0) {
+            for (const [to, weight] of toMap) {
+                toMap.set(to, (weight / totalRefs) * multiplier);
+            }
+        }
+    }
+    // Normalize symbolEdges similarly
+    for (const [from, toMap] of symbolEdgesBuilder) {
+        const totalRefs = rawOutWeights.get(from) ?? 1;
+        const multiplier = getMultiplier(from);
+        if (totalRefs > 0) {
+            for (const [, symbolMap] of toMap) {
+                for (const [symbol, weight] of symbolMap) {
+                    symbolMap.set(symbol, (weight / totalRefs) * multiplier);
+                }
+            }
+        }
+    }
+    // Compute final outWeights (normalized * multiplier)
+    const outWeights = new Map();
+    for (const [from, toMap] of edgesBuilder) {
+        let total = 0;
+        for (const weight of toMap.values()) {
+            total += weight;
+        }
+        outWeights.set(from, total);
+    }
+    return {
+        nodes,
+        edges: edgesBuilder,
+        symbolEdges: symbolEdgesBuilder,
+        outWeights,
+        defsByName,
+    };
+}
+/**
+ * Build import graph with binary edges (1 per file→file relationship).
+ * Captures module structure without reference frequency noise.
+ *
+ * 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.
+ */
+export function buildImportGraph(tags, options) {
+    const getMultiplier = options?.edgeWeightMultiplier ?? (() => 1.0);
+    // First pass: collect nodes and index defs
+    const nodeSet = new Set();
+    const defsByName = new Map();
+    for (const tag of tags) {
+        nodeSet.add(tag.relPath);
+        if (tag.kind === "def") {
+            const existing = defsByName.get(tag.name);
+            if (existing) {
+                existing.push(tag);
+            }
+            else {
+                defsByName.set(tag.name, [tag]);
+            }
+        }
+    }
+    const nodes = [...nodeSet].sort();
+    // Second pass: build binary edges (1 per unique file→file connection)
+    // Track unique file→file relationships, not ref counts
+    const edgesBuilder = new Map();
+    const symbolEdgesBuilder = new Map();
+    const seenEdges = new Map(); // from → Set<to>
+    for (const tag of tags) {
+        if (tag.kind !== "ref")
+            continue;
+        const defs = defsByName.get(tag.name);
+        if (!defs)
+            continue;
+        for (const def of defs) {
+            if (def.relPath === tag.relPath)
+                continue;
+            const from = tag.relPath;
+            const to = def.relPath;
+            // Check if we already have this edge (binary: only count once)
+            let fromSeen = seenEdges.get(from);
+            if (!fromSeen) {
+                fromSeen = new Set();
+                seenEdges.set(from, fromSeen);
+            }
+            if (!fromSeen.has(to)) {
+                fromSeen.add(to);
+                // Create binary edge: weight = 1 * multiplier
+                const multiplier = getMultiplier(from);
+                let fromEdges = edgesBuilder.get(from);
+                if (!fromEdges) {
+                    fromEdges = new Map();
+                    edgesBuilder.set(from, fromEdges);
+                }
+                fromEdges.set(to, multiplier);
+                // Symbol edges: just track which symbol connected them (weight 1)
+                let fromSymbolEdges = symbolEdgesBuilder.get(from);
+                if (!fromSymbolEdges) {
+                    fromSymbolEdges = new Map();
+                    symbolEdgesBuilder.set(from, fromSymbolEdges);
+                }
+                let toSymbolEdges = fromSymbolEdges.get(to);
+                if (!toSymbolEdges) {
+                    toSymbolEdges = new Map();
+                    fromSymbolEdges.set(to, toSymbolEdges);
+                }
+                toSymbolEdges.set(tag.name, multiplier);
+            }
         }
     }
-    // Compute outWeights
+    // Compute outWeights (sum of binary edges * multiplier)
     const outWeights = new Map();
     for (const [from, toMap] of edgesBuilder) {
         let total = 0;