interlinked-mapper 0.1.0__py3-none-any.whl

interlinked/visualizer/server.py

@@ -0,0 +1,428 @@
+"""FastAPI server — serves the frontend and provides REST + SSE APIs."""
+
+from __future__ import annotations
+
+import asyncio
+import json
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, Request
+from fastapi.responses import HTMLResponse, JSONResponse, StreamingResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+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
+
+FRONTEND_DIR = Path(__file__).parent / "frontend" / "dist"
+
+
+def _rebuild_graph(project_path: str, graph: CodeGraph) -> dict:
+    """Re-parse a project and rebuild the graph in-place. Returns stats."""
+    from interlinked.analyzer.parser import parse_project
+    from interlinked.analyzer.dead_code import detect_dead_code
+    from interlinked.analyzer.similarity import analyze_similarity
+
+    path = Path(project_path).resolve()
+    if not path.exists():
+        raise ValueError(f"Path does not exist: {path}")
+
+    nodes, edges = parse_project(str(path))
+    graph.build_from(nodes, edges)
+    dead = detect_dead_code(graph)
+    try:
+        analyze_similarity(graph)
+    except Exception:
+        pass
+    return {"path": str(path), "nodes": len(nodes), "edges": len(edges), "dead": len(dead)}
+
+
+def create_app(graph: CodeGraph, initial_path: str | None = None) -> FastAPI:
+    """Create and configure the FastAPI application."""
+    app = FastAPI(title="Interlinked", version="0.1.0")
+    engine = QueryEngine(graph)
+    llm = LLMAdapter(engine)
+    app_state = {"project_path": initial_path or ""}
+    sse_queues: list[asyncio.Queue] = []
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    # ── Broadcast view changes to all SSE clients ────────────────
+
+    def _snapshot_with_layout() -> dict:
+        snap = engine.snapshot()
+        snap["layout"] = compute_layout(
+            [n for n in graph.all_nodes()],
+            graph.all_edges(),
+        )
+        return snap
+
+    def on_view_change(snapshot: dict) -> None:
+        snapshot["layout"] = compute_layout(
+            [n for n in graph.all_nodes()],
+            graph.all_edges(),
+        )
+        msg = json.dumps({"type": "snapshot", "data": snapshot})
+        dead: list[asyncio.Queue] = []
+        for q in sse_queues:
+            try:
+                q.put_nowait(msg)
+            except Exception:
+                dead.append(q)
+        for q in dead:
+            sse_queues.remove(q)
+
+    engine.on_change(on_view_change)
+
+    # ── REST endpoints ───────────────────────────────────────────
+
+    @app.get("/api/project")
+    async def get_project() -> JSONResponse:
+        return JSONResponse({"path": app_state["project_path"]})
+
+    @app.post("/api/switch_project")
+    async def switch_project(body: dict) -> JSONResponse:
+        """Switch to a different project. Re-parses and rebuilds the graph."""
+        project_path = body.get("path", "")
+        if not project_path:
+            return JSONResponse({"error": "No path provided"}, status_code=400)
+        try:
+            result = _rebuild_graph(project_path, graph)
+            app_state["project_path"] = result["path"]
+            engine.reset_filter()
+            from interlinked.models import ViewContext
+            engine.state.context = ViewContext(
+                what=f"Switched to project: {Path(result['path']).name}",
+                why=f"{result['nodes']} symbols, {result['edges']} edges, {result['dead']} dead",
+                where=result["path"],
+                source="system",
+            )
+            engine._notify()
+            return JSONResponse({"result": f"Switched to {result['path']}", **result})
+        except Exception as e:
+            return JSONResponse({"error": str(e)}, status_code=400)
+
+    @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
+        return JSONResponse(content=snap)
+
+    @app.get("/api/stats")
+    async def get_stats() -> JSONResponse:
+        return JSONResponse(content=engine.stats())
+
+    @app.get("/api/health")
+    async def get_health() -> JSONResponse:
+        return JSONResponse(content=json.loads(engine.health()))
+
+    @app.post("/api/command")
+    async def run_command(body: dict) -> JSONResponse:
+        """Execute a command string against the QueryEngine.
+
+        Body: {"command": "view.zoom('module')"}
+        """
+        cmd = body.get("command", "")
+        if not cmd:
+            return JSONResponse({"error": "No command provided"}, status_code=400)
+
+        # Security: only allow access to the engine object
+        local_ns: dict[str, Any] = {"view": engine, "graph": graph}
+        try:
+            # Try as expression first
+            try:
+                result = eval(cmd, {"__builtins__": {}}, local_ns)
+            except SyntaxError:
+                exec(cmd, {"__builtins__": {}}, local_ns)
+                result = "OK"
+
+            # Serialize result
+            if hasattr(result, "model_dump"):
+                result = result.model_dump()
+            elif isinstance(result, list) and result and hasattr(result[0], "model_dump"):
+                result = [r.model_dump() for r in result]
+
+            return JSONResponse({"result": result})
+        except Exception as e:
+            return JSONResponse({"error": str(e)}, status_code=400)
+
+    @app.post("/api/nl")
+    async def natural_language(body: dict) -> JSONResponse:
+        """Natural language command."""
+        text = body.get("text", "")
+        if not text:
+            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
+        return JSONResponse({"result": result, "snapshot": snap})
+
+    @app.post("/api/zoom")
+    async def set_zoom(body: dict) -> JSONResponse:
+        level = body.get("level", "module")
+        result = engine.zoom(level)
+        return JSONResponse({"result": result})
+
+    @app.post("/api/edge_types")
+    async def set_edge_types(body: dict) -> JSONResponse:
+        edge_types = body.get("edge_types", [])
+        result = engine.set_edge_types(edge_types)
+        return JSONResponse({"result": result})
+
+    @app.post("/api/focus")
+    async def set_focus(body: dict) -> JSONResponse:
+        node_id = body.get("node_id", "")
+        depth = body.get("depth", 2)
+        result = engine.focus(node_id, depth)
+        return JSONResponse({"result": result})
+
+    @app.post("/api/query")
+    async def run_query(body: dict) -> JSONResponse:
+        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
+        return JSONResponse({"results": results, "snapshot": snap})
+
+    @app.post("/api/propose")
+    async def propose_function(body: dict) -> JSONResponse:
+        result = engine.propose_function(
+            name=body.get("name", ""),
+            module=body.get("module", ""),
+            calls=body.get("calls"),
+            called_by=body.get("called_by"),
+            signature=body.get("signature"),
+            color=body.get("color"),
+        )
+        return JSONResponse({"result": result})
+
+    @app.post("/api/clear_proposed")
+    async def clear_proposed() -> JSONResponse:
+        result = engine.clear_proposed()
+        return JSONResponse({"result": result})
+
+    @app.post("/api/isolate")
+    async def isolate_target(body: dict) -> JSONResponse:
+        target = body.get("target", "")
+        level = body.get("level", "function")
+        depth = body.get("depth", 3)
+        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
+        return JSONResponse({"result": result, "snapshot": snap})
+
+    @app.post("/api/find_duplicates")
+    async def find_duplicates(body: dict) -> JSONResponse:
+        threshold = body.get("threshold", 0.6)
+        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
+        return JSONResponse({"result": result, "snapshot": snap})
+
+    @app.post("/api/similar_to")
+    async def similar_to(body: dict) -> JSONResponse:
+        target = body.get("target", "")
+        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
+        return JSONResponse({"result": result, "snapshot": snap})
+
+    @app.post("/api/get_context")
+    async def get_context(body: dict) -> JSONResponse:
+        target = body.get("target", "")
+        result = engine.get_context(target)
+        return JSONResponse({"result": result})
+
+    @app.post("/api/reset")
+    async def reset_filters() -> JSONResponse:
+        result = engine.reset_filter()
+        return JSONResponse({"result": 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
+        return JSONResponse({"result": result, "snapshot": snap})
+
+    # ── LLM chat + settings ──────────────────────────────────────
+
+    @app.post("/api/chat")
+    async def chat(body: dict) -> JSONResponse:
+        """Send a natural language message through the LLM adapter.
+
+        Body: {"message": "show me the analyzer module and everything that connects to it"}
+        Returns: {"explanation": str, "commands_run": [...], "results": [...], "snapshot": {...}}
+        """
+        message = body.get("message", "")
+        if not message:
+            return JSONResponse({"error": "No message provided"}, status_code=400)
+
+        result = await llm.chat(message)
+
+        # Set natural language context so the UI knows what it's looking at
+        from interlinked.models import ViewContext
+        explanation = result.get("explanation", "")
+        commands_run = result.get("commands_run", [])
+        # Derive "where" from highlighted nodes
+        highlighted = engine.state.highlighted_node_ids
+        if highlighted:
+            # Get the common scope prefix
+            parts = [h.rsplit(".", 1)[0] for h in highlighted[:10] if "." in h]
+            if parts:
+                common = parts[0]
+                for p in parts[1:]:
+                    while not p.startswith(common) and "." in common:
+                        common = common.rsplit(".", 1)[0]
+                where = common if common else ", ".join(h.split(".")[-1] for h in highlighted[:5])
+            else:
+                where = ", ".join(h.split(".")[-1] for h in highlighted[:5])
+        else:
+            where = ""
+
+        engine.state.context = ViewContext(
+            what=explanation,
+            why=message,
+            where=where,
+            source="llm",
+        )
+        engine._notify()
+
+        # 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
+        result["snapshot"] = snap
+
+        return JSONResponse(result)
+
+    @app.get("/api/system-prompt")
+    async def system_prompt() -> JSONResponse:
+        """Return the system prompt that teaches an LLM how to drive the view.
+
+        Any external LLM agent can GET this to learn the full API.
+        """
+        return JSONResponse({"prompt": get_system_prompt(engine)})
+
+    @app.get("/api/settings")
+    async def get_settings() -> JSONResponse:
+        return JSONResponse({
+            "has_api_key": llm.is_configured,
+            "model": llm.model,
+        })
+
+    @app.post("/api/settings")
+    async def update_settings(body: dict) -> JSONResponse:
+        if "api_key" in body:
+            llm.set_api_key(body["api_key"])
+        if "model" in body:
+            llm.set_model(body["model"])
+        return JSONResponse({
+            "has_api_key": llm.is_configured,
+            "model": llm.model,
+        })
+
+    @app.post("/api/chat/clear")
+    async def clear_chat() -> JSONResponse:
+        llm.clear_history()
+        return JSONResponse({"result": "Chat history cleared."})
+
+    # ── SSE for live updates ─────────────────────────────────────
+
+    @app.get("/api/events")
+    async def sse_events(request: Request) -> StreamingResponse:
+        """Server-Sent Events stream. Pushes snapshot updates to all connected clients."""
+        q: asyncio.Queue = asyncio.Queue(maxsize=50)
+        sse_queues.append(q)
+
+        async def event_generator():
+            # Send initial snapshot
+            snap = _snapshot_with_layout()
+            yield f"data: {json.dumps({'type': 'snapshot', 'data': snap})}\n\n"
+            try:
+                while True:
+                    if await request.is_disconnected():
+                        break
+                    try:
+                        msg = await asyncio.wait_for(q.get(), timeout=30)
+                        yield f"data: {msg}\n\n"
+                    except asyncio.TimeoutError:
+                        # Keepalive
+                        yield ": keepalive\n\n"
+            finally:
+                if q in sse_queues:
+                    sse_queues.remove(q)
+
+        return StreamingResponse(
+            event_generator(),
+            media_type="text/event-stream",
+            headers={"Cache-Control": "no-cache", "X-Accel-Buffering": "no"},
+        )
+
+    # ── Serve frontend (SPA fallback) ────────────────────────────
+
+    @app.get("/")
+    async def serve_index() -> HTMLResponse:
+        index_path = FRONTEND_DIR / "index.html"
+        if index_path.exists():
+            return HTMLResponse(content=index_path.read_text())
+        # Fallback: serve the embedded single-file frontend
+        return HTMLResponse(content=_get_embedded_frontend())
+
+    if FRONTEND_DIR.exists():
+        app.mount("/assets", StaticFiles(directory=FRONTEND_DIR / "assets"), name="assets")
+
+    return app
+
+
+def _get_embedded_frontend() -> str:
+    """Return the single-file embedded frontend HTML."""
+    frontend_file = Path(__file__).parent / "frontend" / "index.html"
+    if frontend_file.exists():
+        return frontend_file.read_text()
+    return "<html><body><h1>Interlinked</h1><p>Frontend not found.</p></body></html>"

interlinked_mapper-0.1.0.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: interlinked-mapper
+Version: 0.1.0
+Summary: A Python program topology explorer — visualize the shape of your codebase
+License: MIT
+Project-URL: Homepage, https://github.com/austerecryptid/interlinked
+Project-URL: Repository, https://github.com/austerecryptid/interlinked
+Keywords: ast,code-analysis,topology,graph,visualization,mcp,networkx
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Documentation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Framework :: FastAPI
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: networkx>=3.1
+Requires-Dist: fastapi>=0.110
+Requires-Dist: uvicorn[standard]>=0.29
+Requires-Dist: pydantic>=2.0
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.0

interlinked_mapper-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+interlinked/__init__.py,sha256=n-e2URoZB6ggGZGUfp2iUF1b99Ik8b77-7kQLxdncAs,81
+interlinked/cli.py,sha256=Txb31yJwBmM0qTG_2v1P4SoHzqZZzX1KlvT44EAkcRM,5354
+interlinked/mcp_server.py,sha256=cPYQkom6GBMxO320dmf7DzFIMVKOI56JBlZyFRfKarY,14028
+interlinked/models.py,sha256=8rnrUsWq4n3Gu3_c5PtLmLSGup_RVlEZzLTxwq1xXuA,3293
+interlinked/analyzer/__init__.py,sha256=IUVK2g10kPb710x4GZ64BM1l46cXFUoPN28KQOKVgog,302
+interlinked/analyzer/dead_code.py,sha256=Om4U8e7hYPLRtewRTEbY2u_3CDQ3jrzB88-QQyyiHno,5767
+interlinked/analyzer/graph.py,sha256=zyEjTm9RdL95jNmQ5fNTV2Ni9YmfpLtGySvpN4He8lw,33789
+interlinked/analyzer/parser.py,sha256=RQscrCC-gswyreHl-_XmZi4pWFMfzM88rXiHg_EMfl8,48798
+interlinked/analyzer/similarity.py,sha256=F2eo2PorcKFdR3eqZU-NlUjUO38Gox_Z-5uJaJ9sbck,17599
+interlinked/commander/__init__.py,sha256=u3mUgPptlhh3ieYuBw1c4Mcg03mqti6sCydNi1fMkeg,211
+interlinked/commander/llm.py,sha256=OXwl_0ZDhUNditnIP0piKS4CPlv4rdaNw2m8ixzeu88,13864
+interlinked/commander/query.py,sha256=xAgvek1NRRg7eGjyk1dUeVaUzGqES0EzF5jIzQA7bq4,43553
+interlinked/commander/repl.py,sha256=_5Y-x8EVvbSuV2B8gKVJ2hxz30VjZSO0ZSUDkrDgHMo,2001
+interlinked/visualizer/__init__.py,sha256=JbjxQIkzieTfneMTrD55D85dNQVbG_ApOON0WauWPxU,54
+interlinked/visualizer/layouts.py,sha256=PQI-jX0xUk434opZ3YDGvpSlxuM1Z3VTpvpWK0LsUv0,5122
+interlinked/visualizer/server.py,sha256=PKXWd-_YP37kNLpbrmnvryao1VvN7URxH8XaXHXbmU8,16005
+interlinked_mapper-0.1.0.dist-info/METADATA,sha256=zyLHl3crVsKNWXrznX_6oQkKvq3iajREtXSnNYUfmu0,1106
+interlinked_mapper-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+interlinked_mapper-0.1.0.dist-info/entry_points.txt,sha256=a_FXoNklFSXCPppdEZkxsyyV9FXYO63rPgerO06glTA,53
+interlinked_mapper-0.1.0.dist-info/top_level.txt,sha256=yRUrFRu0dPsOlTUmNsnA7AziN-ITuSn4222SH7h7_uA,12
+interlinked_mapper-0.1.0.dist-info/RECORD,,

interlinked_mapper-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

interlinked_mapper-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+interlinked = interlinked.cli:main

interlinked_mapper-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+interlinked