interlinked-mapper 0.1.8__tar.gz → 0.2.0__tar.gz

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlinked-mapper
-Version: 0.1.8
+Version: 0.2.0
 Summary: A Python program topology explorer — visualize the shape of your codebase
 License: MIT
 Project-URL: Homepage, https://github.com/austerecryptid/interlinked

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/interlinked/commander/llm.py

@@ -62,12 +62,16 @@ You control what they see by emitting Python commands against the `view` object.
 
 ### Queries
 - `view.query("dead functions")` — Find dead/uncalled code (highlights results)
+- `view.query("dead functions in <scope>")` — Dead functions scoped to a module prefix, e.g. `"dead functions in engine.rules.ir_exec"`
+- `view.query("dead classes in <scope>")` — Dead classes in a scope
 - `view.query("callers of <name>")` — Who calls this?
 - `view.query("callees of <name>")` — What does this call?
 - `view.query("parameters of <name>")` — Show function parameters
 - `view.query("returns of <name>")` — Show what a function returns (project symbols)
 - `view.query("external calls in <name>")` — Show external library calls from a module/class/function
 - `view.query("external calls")` — All external calls in the project
+- `view.query("functions in <scope>")` — List all functions/methods under a module prefix, e.g. `"functions in engine.rules"`
+- `view.query("classes in <scope>")` — List all classes under a module prefix
 - `view.query("modules")` / `view.query("classes")` / `view.query("functions")` / `view.query("parameters")` / `view.query("variables")`
 - `view.query("<search_term>")` — Fuzzy name search
 
@@ -82,6 +86,19 @@ You control what they see by emitting Python commands against the `view` object.
 - `view.path_between(source, target)` — Shortest dependency chain between two symbols.
 - `view.all_paths(source, target, max_depth=8)` — Every route between two symbols.
 
+### Cross-Module Edge Enumeration
+- `view.edges_between(source_scope, target_scope=None, edge_types=None)` — List all edges leaving a module scope, grouped by target module. Essential for module isolation checks.
+  - `view.edges_between("engine.rules.resolver")` — ALL outgoing edges from resolver
+  - `view.edges_between("engine.rules.resolver", target_scope="engine.systems")` — Only edges going to engine.systems
+  - `view.edges_between("engine.rules", edge_types=["imports"])` — Only import edges
+  - `view.edges_between("engine.rules", edge_types=["calls", "imports"])` — Calls + imports
+
+### Reachability (Purity / Isolation Checks)
+- `view.reachable(source, target, edge_types=None, max_depth=20)` — Check if target is reachable from source via specific edge types. Default: follows only call edges.
+  - `view.reachable("resolve_effects", "world.set_component")` — Is there ANY call path? Returns path if yes.
+  - `view.reachable("resolver.resolve", "db.commit", edge_types=["calls", "imports"])` — Check calls + imports
+  - Returns JSON: `{{"reachable": true/false, "path": [...], "short_path": "A → B → C"}}`
+
 ### Architecture Health
 - `view.find_cycles()` — Find and highlight circular dependencies (calls/imports).
 - `view.critical_nodes(top_n=20)` — Most important symbols by PageRank.

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/interlinked/commander/query.py

@@ -305,9 +305,26 @@ class QueryEngine:
             results = self.graph.functions_returning(type_hint)
 
         elif "dead" in expr or "uncalled" in expr:
+            # Support scoped dead queries: "dead functions in engine.rules"
+            scope = None
+            scope_match = re.search(r'(?:dead|uncalled)\s+\w+\s+in\s+(\S+)', expression, re.IGNORECASE)
+            if scope_match:
+                scope = scope_match.group(1)
+            # Support type filter: "dead functions" vs "dead classes" vs just "dead"
+            type_filter: set[SymbolType] | None = None
+            if "function" in expr or "method" in expr:
+                type_filter = {SymbolType.FUNCTION, SymbolType.METHOD}
+            elif "class" in expr:
+                type_filter = {SymbolType.CLASS}
+            elif "module" in expr:
+                type_filter = {SymbolType.MODULE}
+            elif "variable" in expr:
+                type_filter = {SymbolType.VARIABLE}
             results = [
                 n for n in self.graph.all_nodes()
                 if n.is_dead
+                and (type_filter is None or n.symbol_type in type_filter)
+                and (scope is None or n.qualified_name.startswith(scope))
             ]
 
         elif expr.startswith("imports of"):
@@ -316,22 +333,34 @@ class QueryEngine:
             return [e.model_dump() for e in edges]
 
         elif expr.startswith("modules"):
+            scope = self._parse_scope(expression, "modules")
             results = self.graph.nodes_by_type(SymbolType.MODULE)
+            if scope:
+                results = [n for n in results if n.qualified_name.startswith(scope)]
 
         elif expr.startswith("classes"):
+            scope = self._parse_scope(expression, "classes")
             results = self.graph.nodes_by_type(SymbolType.CLASS)
+            if scope:
+                results = [n for n in results if n.qualified_name.startswith(scope)]
 
         elif expr.startswith("functions") or expr.startswith("methods"):
+            scope = self._parse_scope(expression, "functions") or self._parse_scope(expression, "methods")
             results = (
                 self.graph.nodes_by_type(SymbolType.FUNCTION)
                 + self.graph.nodes_by_type(SymbolType.METHOD)
             )
+            if scope:
+                results = [n for n in results if n.qualified_name.startswith(scope)]
 
         elif expr.startswith("parameters") or expr.startswith("variables"):
+            scope = self._parse_scope(expression, "parameters") or self._parse_scope(expression, "variables")
             results = [
                 n for n in self.graph.all_nodes()
                 if n.symbol_type == (SymbolType.PARAMETER if "param" in expr else SymbolType.VARIABLE)
             ]
+            if scope:
+                results = [n for n in results if n.qualified_name.startswith(scope)]
 
         else:
             # Fuzzy name search
@@ -652,6 +681,11 @@ class QueryEngine:
 
     # ── Helper ───────────────────────────────────────────────────────
 
+    def _parse_scope(self, expression: str, keyword: str) -> str | None:
+        """Extract scope from 'keyword in scope' pattern, e.g. 'functions in engine.rules'."""
+        m = re.search(rf'{keyword}\s+in\s+(\S+)', expression, re.IGNORECASE)
+        return m.group(1) if m else None
+
     def _resolve_node(self, name: str) -> NodeData | None:
         """Resolve a name to a node, with fuzzy matching."""
         node = self.graph.get_node(name)
@@ -776,6 +810,154 @@ class QueryEngine:
         context = get_rich_context(self.graph, node)
         return json.dumps(context, indent=2, default=str)
 
+    # ── Cross-module edge enumeration ────────────────────────────────
+
+    def edges_between(
+        self,
+        source_scope: str,
+        target_scope: str | None = None,
+        edge_types: list[str] | None = None,
+    ) -> str:
+        """List all edges from one module scope to another (or to everything external).
+
+        Args:
+            source_scope: Qualified name prefix of the source module, e.g. "engine.rules.resolver".
+            target_scope: Optional target prefix. If omitted, shows all edges leaving source_scope.
+            edge_types: Optional filter, e.g. ["calls", "imports"]. Default: all types.
+
+        Returns JSON with edges grouped by target module.
+        """
+        et_filter = None
+        if edge_types:
+            et_filter = set()
+            for et_str in edge_types:
+                try:
+                    et_filter.add(EdgeType(et_str))
+                except ValueError:
+                    pass
+
+        all_edges = self.graph.all_edges(include_proposed=False)
+        source_nodes = {n.id for n in self.graph.all_nodes() if n.qualified_name.startswith(source_scope)}
+
+        edges_out: list[dict] = []
+        for e in all_edges:
+            if e.source not in source_nodes:
+                continue
+            if et_filter and e.edge_type not in et_filter:
+                continue
+            # Skip edges within the source scope (internal)
+            target_node = self.graph.get_node(e.target)
+            target_qname = target_node.qualified_name if target_node else e.target
+            if target_qname.startswith(source_scope):
+                continue
+            # If target_scope specified, filter to it
+            if target_scope and not target_qname.startswith(target_scope):
+                continue
+            edges_out.append({
+                "source": e.source,
+                "target": e.target,
+                "edge_type": e.edge_type.value,
+                "line": e.line,
+            })
+
+        # Group by target module (first two dotted components of target)
+        by_module: dict[str, list[dict]] = {}
+        for edge in edges_out:
+            tgt = edge["target"]
+            parts = tgt.split(".")
+            mod = ".".join(parts[:2]) if len(parts) > 1 else parts[0]
+            by_module.setdefault(mod, []).append(edge)
+
+        result = {
+            "source_scope": source_scope,
+            "target_scope": target_scope or "(all external)",
+            "total_edges": len(edges_out),
+            "by_target_module": {
+                mod: {"count": len(edges), "edges": edges}
+                for mod, edges in sorted(by_module.items(), key=lambda x: -len(x[1]))
+            },
+        }
+
+        # Highlight source nodes in view
+        self.state.highlighted_node_ids = list({e["source"] for e in edges_out})
+        self._notify()
+
+        return json.dumps(result, indent=2)
+
+    # ── Reachability ─────────────────────────────────────────────────
+
+    def reachable(
+        self,
+        source: str,
+        target: str,
+        edge_types: list[str] | None = None,
+        max_depth: int = 20,
+    ) -> str:
+        """Check if target is reachable from source via specific edge types.
+
+        By default follows only 'calls' edges — use for purity/isolation checks.
+        Returns the shortest path if reachable, or a clear "not reachable" message.
+
+        Args:
+            source: Qualified name of the source symbol.
+            target: Qualified name (or partial) of the target symbol.
+            edge_types: Edge types to traverse (default: ["calls"]).
+            max_depth: Maximum path length to search.
+        """
+        import networkx as nx
+
+        src_node = self._resolve_node(source)
+        tgt_node = self._resolve_node(target)
+        if not src_node:
+            return json.dumps({"reachable": False, "error": f"Source '{source}' not found."})
+        if not tgt_node:
+            return json.dumps({"reachable": False, "error": f"Target '{target}' not found."})
+
+        # Build edge-type-filtered subgraph
+        et_filter = set()
+        for et_str in (edge_types or ["calls"]):
+            try:
+                et_filter.add(EdgeType(et_str).value)
+            except ValueError:
+                pass
+        if not et_filter:
+            et_filter = {"calls"}
+
+        sub_edges = [
+            (u, v) for u, v, d in self.graph._g.edges(data=True)
+            if d.get("edge_type") in et_filter
+        ]
+        sub_g = nx.DiGraph()
+        sub_g.add_edges_from(sub_edges)
+
+        try:
+            path = nx.shortest_path(sub_g, src_node.id, tgt_node.id)
+            if len(path) - 1 > max_depth:
+                return json.dumps({"reachable": False, "reason": f"Path exists but exceeds max_depth={max_depth}."})
+
+            # Highlight the path
+            self.state.highlighted_node_ids = list(path)
+            self.state.trace_node_roles = {path[0]: "origin", path[-1]: "destination"}
+            for nid in path[1:-1]:
+                self.state.trace_node_roles[nid] = "passthrough"
+            self.state.trace_edge_roles = {}
+            self._notify()
+
+            short_path = " → ".join(n.split(".")[-1] for n in path)
+            return json.dumps({
+                "reachable": True,
+                "path_length": len(path) - 1,
+                "path": list(path),
+                "short_path": short_path,
+            }, indent=2)
+        except (nx.NetworkXNoPath, nx.NodeNotFound):
+            return json.dumps({
+                "reachable": False,
+                "source": src_node.qualified_name,
+                "target": tgt_node.qualified_name,
+                "edge_types": list(et_filter),
+            })
+
     # ── Display settings ─────────────────────────────────────────────
 
     @property

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/interlinked/mcp_server.py

@@ -141,7 +141,7 @@ def create_mcp_server(project_path: str) -> Server:
             ),
             Tool(
                 name="interlinked_query",
-                description="Run a structured query against the codebase graph. Supports: 'dead functions', 'callers of X', 'callees of X', 'modules', 'classes', 'functions', or any search term for fuzzy name matching.",
+                description="Run a structured query against the codebase graph. Supports: 'callers of X', 'callees of X', 'dead functions', 'dead functions in <scope>', 'functions in <scope>', 'classes in <scope>', 'modules in <scope>', 'external calls in <scope>', 'imports of X', 'functions returning <type>', or any search term for fuzzy name matching. The 'in <scope>' suffix filters by qualified name prefix.",
                 inputSchema={
                     "type": "object",
                     "properties": {
@@ -233,6 +233,33 @@ def create_mcp_server(project_path: str) -> Server:
                     "required": ["path"],
                 },
             ),
+            Tool(
+                name="interlinked_edges_between",
+                description="List all edges (calls, imports, etc.) from one module scope to another, or to everything outside the scope. Returns edges grouped by target module. Essential for module isolation checks.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "source_scope": {"type": "string", "description": "Qualified name prefix of source, e.g. 'engine.rules.resolver'"},
+                        "target_scope": {"type": "string", "description": "Optional: qualified name prefix of target to filter to, e.g. 'engine.systems'. Omit to see ALL outgoing edges."},
+                        "edge_types": {"type": "array", "items": {"type": "string"}, "description": "Optional: edge types to include (calls, imports, inherits, reads, writes). Default: all."},
+                    },
+                    "required": ["source_scope"],
+                },
+            ),
+            Tool(
+                name="interlinked_reachable",
+                description="Check if there is any path from source to target following specific edge types (default: calls only). Use for purity contracts and isolation verification. Returns the shortest path if reachable.",
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "source": {"type": "string", "description": "Qualified name of the source symbol"},
+                        "target": {"type": "string", "description": "Qualified name (or partial) of the target symbol"},
+                        "edge_types": {"type": "array", "items": {"type": "string"}, "description": "Edge types to traverse (default: ['calls'])"},
+                        "max_depth": {"type": "integer", "description": "Maximum path length (default: 20)", "default": 20},
+                    },
+                    "required": ["source", "target"],
+                },
+            ),
             Tool(
                 name="interlinked_reset",
                 description="Reset all filters, focus, and highlights back to the default full-graph view.",
@@ -320,6 +347,17 @@ def _dispatch_via_server(name: str, args: dict[str, Any], server_url: str) -> st
         "interlinked_get_context": ("POST", "/api/get_context", {"target": args.get("target", "")}),
         "interlinked_command":     ("POST", "/api/command", {"command": args.get("command", "")}),
         "interlinked_switch_project": ("POST", "/api/switch_project", {"path": args.get("path", "")}),
+        "interlinked_edges_between": ("POST", "/api/edges_between", {
+            "source_scope": args.get("source_scope", ""),
+            "target_scope": args.get("target_scope"),
+            "edge_types": args.get("edge_types"),
+        }),
+        "interlinked_reachable":   ("POST", "/api/reachable", {
+            "source": args.get("source", ""),
+            "target": args.get("target", ""),
+            "edge_types": args.get("edge_types"),
+            "max_depth": args.get("max_depth", 20),
+        }),
         "interlinked_reset":       ("POST", "/api/reset", {}),
     }
 
@@ -424,6 +462,21 @@ def _dispatch_tool(
         engine.reset_filter()
         return json.dumps(result, indent=2)
 
+    elif name == "interlinked_edges_between":
+        return engine.edges_between(
+            source_scope=args["source_scope"],
+            target_scope=args.get("target_scope"),
+            edge_types=args.get("edge_types"),
+        )
+
+    elif name == "interlinked_reachable":
+        return engine.reachable(
+            source=args["source"],
+            target=args["target"],
+            edge_types=args.get("edge_types"),
+            max_depth=args.get("max_depth", 20),
+        )
+
     elif name == "interlinked_reset":
         return engine.reset_filter()
 

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/interlinked/visualizer/server.py

@@ -16,7 +16,7 @@ from interlinked.analyzer.graph import CodeGraph
 from interlinked.commander.query import QueryEngine
 from interlinked.commander.llm import LLMAdapter, get_system_prompt
 from interlinked.visualizer.layouts import compute_layout
-from interlinked.models import ViewState
+from interlinked.models import ViewState, NodeData, EdgeData
 
 FRONTEND_DIR = Path(__file__).parent / "frontend" / "dist"
 
@@ -59,19 +59,19 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
 
     # ── Broadcast view changes to all SSE clients ────────────────
 
+    def _layout_from_snap(snap: dict) -> dict:
+        """Compute layout from the snapshot's visible nodes/edges only."""
+        snap_nodes = [NodeData(**n) for n in snap.get("nodes", [])]
+        snap_edges = [EdgeData(**e) for e in snap.get("edges", [])]
+        return compute_layout(snap_nodes, snap_edges)
+
     def _snapshot_with_layout() -> dict:
         snap = engine.snapshot()
-        snap["layout"] = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
+        snap["layout"] = _layout_from_snap(snap)
         return snap
 
     def on_view_change(snapshot: dict) -> None:
-        snapshot["layout"] = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
+        snapshot["layout"] = _layout_from_snap(snapshot)
         msg = json.dumps({"type": "snapshot", "data": snapshot})
         dead: list[asyncio.Queue] = []
         for q in sse_queues:
@@ -115,11 +115,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
     @app.get("/api/snapshot")
     async def get_snapshot() -> JSONResponse:
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse(content=snap)
 
     @app.get("/api/stats")
@@ -168,11 +164,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
             return JSONResponse({"error": "No text provided"}, status_code=400)
         result = engine.nl(text)
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse({"result": result, "snapshot": snap})
 
     @app.post("/api/zoom")
@@ -199,11 +191,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
         expr = body.get("expression", "")
         results = engine.query(expr)
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse({"results": results, "snapshot": snap})
 
     @app.post("/api/propose")
@@ -231,11 +219,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
         edge_types = body.get("edge_types")
         result = engine.isolate(target, level=level, depth=depth, edge_types=edge_types)
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse({"result": result, "snapshot": snap})
 
     @app.post("/api/find_duplicates")
@@ -244,11 +228,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
         scope = body.get("scope")
         result = engine.find_duplicates(threshold=threshold, scope=scope)
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse({"result": result, "snapshot": snap})
 
     @app.post("/api/similar_to")
@@ -257,11 +237,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
         threshold = body.get("threshold", 0.5)
         result = engine.similar_to(target, threshold=threshold)
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse({"result": result, "snapshot": snap})
 
     @app.post("/api/get_context")
@@ -275,17 +251,32 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
         result = engine.reset_filter()
         return JSONResponse({"result": result})
 
+    @app.post("/api/edges_between")
+    async def edges_between(body: dict) -> JSONResponse:
+        result = engine.edges_between(
+            source_scope=body.get("source_scope", ""),
+            target_scope=body.get("target_scope"),
+            edge_types=body.get("edge_types"),
+        )
+        return JSONResponse(content=json.loads(result))
+
+    @app.post("/api/reachable")
+    async def reachable(body: dict) -> JSONResponse:
+        result = engine.reachable(
+            source=body.get("source", ""),
+            target=body.get("target", ""),
+            edge_types=body.get("edge_types"),
+            max_depth=body.get("max_depth", 20),
+        )
+        return JSONResponse(content=json.loads(result))
+
     @app.post("/api/trace_variable")
     async def trace_variable(body: dict) -> JSONResponse:
         var_name = body.get("variable", "")
         origin = body.get("origin")
         result = engine.trace_variable(var_name, origin)
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         return JSONResponse({"result": result, "snapshot": snap})
 
     # ── LLM chat + settings ──────────────────────────────────────
@@ -333,11 +324,7 @@ def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
 
         # Always return fresh snapshot after commands have executed
         snap = engine.snapshot()
-        layout = compute_layout(
-            [n for n in graph.all_nodes()],
-            graph.all_edges(),
-        )
-        snap["layout"] = layout
+        snap["layout"] = _layout_from_snap(snap)
         result["snapshot"] = snap
 
         return JSONResponse(result)

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/interlinked_mapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: interlinked-mapper
-Version: 0.1.8
+Version: 0.2.0
 Summary: A Python program topology explorer — visualize the shape of your codebase
 License: MIT
 Project-URL: Homepage, https://github.com/austerecryptid/interlinked

{interlinked_mapper-0.1.8 → interlinked_mapper-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "interlinked-mapper"
-version = "0.1.8"
+version = "0.2.0"
 description = "A Python program topology explorer — visualize the shape of your codebase"
 readme = "README.md"
 license = {text = "MIT"}