codegraph-engine 2.3.0__py3-none-any.whl → 3.0.1__py3-none-any.whl

codegraph/interrogation.py

@@ -548,6 +548,8 @@ _TEXT_LANGUAGE_MAP: dict[str, str] = {
     ".sql": "sql",
     ".prisma": "prisma",
     ".sh": "shell",
+    ".lua": "luau",
+    ".luau": "luau",
 }
 
 
@@ -1500,7 +1502,7 @@ def trace_path(
             "path": [],
         }
 
-    # Resolve from and to targets (prefer exact canonical_id or qualified_name)
+    # Resolve from and to targets (prefer exact canonical_id or qualified_name, or virtual graph_edges nodes like Remotes)
     from_row = con.execute(
         "SELECT canonical_id, qualified_name, name FROM symbols "
         "WHERE canonical_id=? OR qualified_name=? OR name=? "
@@ -1515,8 +1517,27 @@ def trace_path(
         (clean_to, clean_to, clean_to, clean_to, clean_to),
     ).fetchone()
 
-    if not from_row or not to_row:
-        missing = clean_from if not from_row else clean_to
+    # Fallback: check if clean_from or clean_to is a virtual node in graph_edges (e.g. ReplicatedStorage.Remotes.Inventory or persistence.roblox.datastore.PlayerData)
+    from_virtual: str | None = None
+    if not from_row:
+        ge_from = con.execute(
+            "SELECT source, target FROM graph_edges WHERE source=? OR target=? LIMIT 1",
+            (clean_from, clean_from),
+        ).fetchone()
+        if ge_from:
+            from_virtual = clean_from
+
+    to_virtual: str | None = None
+    if not to_row:
+        ge_to = con.execute(
+            "SELECT source, target FROM graph_edges WHERE source=? OR target=? LIMIT 1",
+            (clean_to, clean_to),
+        ).fetchone()
+        if ge_to:
+            to_virtual = clean_to
+
+    if (not from_row and not from_virtual) or (not to_row and not to_virtual):
+        missing = clean_from if (not from_row and not from_virtual) else clean_to
         return {
             "status": "not_found",
             "error": {
@@ -1533,11 +1554,24 @@ def trace_path(
             "path": [],
         }
 
-    start_canon = from_row["canonical_id"]
-    target_canon = to_row["canonical_id"]
-    target_names = {to_row["canonical_id"], to_row["qualified_name"]}
-    if "." not in clean_to:
+    start_canon = from_row["canonical_id"] if from_row else str(from_virtual)
+    target_canon = to_row["canonical_id"] if to_row else str(to_virtual)
+    target_names = (
+        {to_row["canonical_id"], to_row["qualified_name"]}
+        if to_row
+        else {target_canon}
+    )
+    if to_row and "." not in clean_to:
         target_names.add(to_row["name"])
+    # Also include child methods of target_canon if target_canon is a class/service table
+    if to_row:
+        child_rows = con.execute(
+            "SELECT canonical_id, qualified_name FROM symbols WHERE parent_symbol_id=?",
+            (target_canon,),
+        ).fetchall()
+        for cr in child_rows:
+            target_names.add(str(cr["canonical_id"]))
+            target_names.add(str(cr["qualified_name"]))
 
     if start_canon == target_canon:
         return {
@@ -1558,40 +1592,57 @@ def trace_path(
         if len(path) >= bounded_depth:
             continue
 
+        # Expand curr_sym to include its direct child methods when curr_sym is a class/table
+        curr_candidates = [curr_sym]
+        child_syms = con.execute(
+            "SELECT canonical_id FROM symbols WHERE parent_symbol_id=?",
+            (curr_sym,),
+        ).fetchall()
+        for cs in child_syms:
+            curr_candidates.append(str(cs["canonical_id"]))
+        ph_curr = ",".join("?" for _ in curr_candidates)
+
         # 1. Query outgoing edges from graph_edges
         graph_rows = con.execute(
-            "SELECT target, relationship, confidence, evidence_class, file, start_line, end_line "
+            "SELECT source, target, relationship, confidence, evidence_class, file, start_line, end_line "
             "FROM graph_edges "
-            "WHERE source=? AND relationship IN ("
+            f"WHERE source IN ({ph_curr}) AND relationship IN ("
             "'CALLS', 'DEFINES', 'CONTAINS', 'IMPORTS', 'HANDLED_BY', 'ROUTES_TO', "
-            "'PROVIDES', 'INJECTS', 'RESOLVES_DEPENDENCY', 'DISPATCHES_TO', 'REGISTERS'"
+            "'PROVIDES', 'INJECTS', 'RESOLVES_DEPENDENCY', 'DISPATCHES_TO', 'REGISTERS', "
+            "'PRODUCES_TO_QUEUE', 'CONSUMES_FROM_QUEUE', 'STATIC_QUEUE_LINKED', 'OTEL_DISTRIBUTED_VERIFIED', "
+            "'DISPATCHES_TASK', 'TRIGGERS_SIGNAL', 'HANDLES_SIGNAL', 'RENDERS_TEMPLATE', "
+            "'DISPATCHES_FORWARD', 'TOOL_HANDLER', 'PIPELINE_STEP', "
+            "'REQUIRES_MODULE', 'CLIENT_DISPATCHES_REMOTE', 'SERVER_HANDLES_REMOTE', "
+            "'GETS_SERVICE', 'PROVIDES_SERVICE', 'READS_PERSISTENCE', 'WRITES_PERSISTENCE', 'CONFIGURES_PERSISTENCE'"
             ") AND confidence IN ('HIGH', 'MEDIUM') "
             "ORDER BY relationship ASC, target ASC",
-            (curr_sym,),
+            curr_candidates,
         ).fetchall()
 
         # 2. Query outgoing verified CALLS from references
         ref_rows = con.execute(
-            "SELECT target_symbol_id, relationship, confidence, path, start_line, end_line, evidence "
+            "SELECT source_symbol_id, target_symbol_id, relationship, confidence, path, start_line, end_line, evidence "
             "FROM 'references' "
-            "WHERE source_symbol_id=? AND relationship='CALLS' AND confidence IN ('HIGH', 'MEDIUM') AND target_symbol_id IS NOT NULL "
+            f"WHERE source_symbol_id IN ({ph_curr}) AND relationship='CALLS' AND confidence IN ('HIGH', 'MEDIUM') AND target_symbol_id IS NOT NULL "
             "ORDER BY path ASC, start_line ASC",
-            (curr_sym,),
+            curr_candidates,
         ).fetchall()
 
         # 3. Query outgoing resolved calls from calls table
         edges = con.execute(
             "SELECT c.callee, c.qualified_callee, c.resolved_symbol_id, c.confidence, c.source_path, c.line "
             "FROM calls c "
-            "WHERE c.source_symbol_id=? AND (c.resolved_symbol_id IS NOT NULL OR c.confidence IN ('HIGH', 'MEDIUM')) "
+            f"WHERE c.source_symbol_id IN ({ph_curr}) AND (c.resolved_symbol_id IS NOT NULL OR c.confidence IN ('HIGH', 'MEDIUM')) "
             "ORDER BY c.source_path ASC, c.line ASC",
-            (curr_sym,),
+            curr_candidates,
         ).fetchall()
 
         step_map: dict[tuple[str, str], tuple[str, str, str, str, str, int, int]] = {}
         for g in graph_rows:
             dest = str(g["target"])
             rel = str(g["relationship"])
+            if rel == "CONTAINS" and dest in curr_candidates:
+                continue
             conf = str(g["confidence"] or "HIGH").upper()
             ev_cls = str(g["evidence_class"] or "AST_VERIFIED").upper()
             step_map[(dest, rel)] = (dest, rel, conf, ev_cls, str(g["file"] or ""), int(g["start_line"] or 1), int(g["end_line"] or g["start_line"] or 1))
@@ -1615,17 +1666,26 @@ def trace_path(
 
         for dest_sym, rel, conf, ev_cls, s_file, s_line, e_line in all_steps:
             dest_row = con.execute(
-                "SELECT canonical_id FROM symbols "
+                "SELECT canonical_id, parent_symbol_id FROM symbols "
                 "WHERE canonical_id=? OR qualified_name=? OR name=? "
                 "ORDER BY (canonical_id=?) DESC, (qualified_name=?) DESC LIMIT 1",
                 (dest_sym, dest_sym, dest_sym, dest_sym, dest_sym),
             ).fetchone()
             dest_canon = dest_row["canonical_id"] if dest_row else dest_sym
+            dest_parent = dest_row["parent_symbol_id"] if dest_row else None
+
+            matched_target = (
+                dest_canon == target_canon
+                or dest_sym in target_names
+                or dest_canon in target_names
+                or (dest_parent is not None and dest_parent == target_canon)
+            )
+            effective_target = target_canon if matched_target else dest_canon
 
             new_path = list(path) + [
                 {
                     "source": curr_sym,
-                    "target": dest_canon,
+                    "target": effective_target,
                     "relationship": rel,
                     "confidence": conf,
                     "evidence_class": ev_cls,
@@ -1636,12 +1696,12 @@ def trace_path(
                         start_line=s_line,
                         end_line=e_line,
                         evidence_type="path_edge",
-                        canonical_id=dest_canon,
+                        canonical_id=effective_target,
                     ),
                 }
             ]
 
-            if dest_canon == target_canon or dest_sym in target_names:
+            if matched_target:
                 return {
                     "status": "ok",
                     "from": clean_from,
@@ -1656,6 +1716,9 @@ def trace_path(
             if dest_canon and dest_canon not in visited:
                 visited.add(dest_canon)
                 queue.append((dest_canon, new_path))
+            if dest_parent and dest_parent not in visited:
+                visited.add(dest_parent)
+                queue.append((dest_parent, new_path))
 
     return {
         "status": "not_found",
@@ -2010,25 +2073,130 @@ def list_routes(
     except sqlite3.OperationalError:
         rows = []
 
-    routes = [
-        {
-            "method": r["http_method"],
-            "path": r["route_path"],
-            "handler": r["handler_canonical_id"] or r["handler_name"],
-            "file": r["file_path"],
-            "start_line": r["line"],
-            "end_line": r["line"],
-            "framework": r["framework"],
-            "evidence": make_evidence(
-                file=r["file_path"],
-                start_line=r["line"],
-                end_line=r["line"],
-                evidence_type="route",
-                canonical_id=r["handler_canonical_id"],
-            ),
-        }
-        for r in rows
-    ]
+    # Fetch HTMX requests and template rendering edges if available
+    htmx_rows: list[sqlite3.Row] = []
+    try:
+        htmx_rows = con.execute(
+            "SELECT target_name, file_path, line, base_expr, dict_entries_json "
+            "FROM local_bindings WHERE expr_kind='HTMX_REQUEST'"
+        ).fetchall()
+    except sqlite3.OperationalError:
+        pass
+
+    template_edges: dict[str, list[dict[str, Any]]] = {}
+    try:
+        t_rows = con.execute(
+            "SELECT source, target, file, start_line FROM graph_edges WHERE relationship='RENDERS_TEMPLATE'"
+        ).fetchall()
+        for tr in t_rows:
+            template_edges.setdefault(tr["source"], []).append(
+                {
+                    "template": tr["target"],
+                    "file": tr["file"],
+                    "line": tr["start_line"],
+                }
+            )
+    except sqlite3.OperationalError:
+        pass
+
+    def _route_matches_url(route_path: str, url: str, handler_name: str = "", handler_canon: str = "") -> bool:
+        if not route_path or not url:
+            return False
+        if handler_name and (url == handler_name or url.endswith(f".{handler_name}")):
+            return True
+        if handler_canon and url in handler_canon:
+            return True
+        rp = route_path.rstrip("/") or "/"
+        u = url.rstrip("/") or "/"
+        if rp == u:
+            return True
+        u_clean = u.split("?")[0]
+        if rp == u_clean:
+            return True
+        import re
+        pattern = re.sub(r"<[^>]+>", r"[^/]+", rp)
+        pattern = re.sub(r"\{[^}]+\}", r"[^/]+", pattern)
+        pattern = re.sub(r":[\w]+", r"[^/]+", pattern)
+        pattern = f"^{pattern}$"
+        try:
+            return bool(re.match(pattern, u_clean))
+        except Exception:
+            return False
+
+    routes = []
+    for r in rows:
+        r_path = r["route_path"]
+        r_method = (r["http_method"] or "").upper()
+        h_canon = r["handler_canonical_id"] or ""
+        h_name = r["handler_name"] or ""
+
+        # Match HTMX callers
+        htmx_callers: list[dict[str, Any]] = []
+        for hb in htmx_rows:
+            url = hb["target_name"]
+            hb_method = (hb["base_expr"] or "").upper()
+            if (not hb_method or hb_method == r_method or r_method in ("ALL", "ANY")) and _route_matches_url(
+                r_path, url, h_name, h_canon
+            ):
+                import json
+                meta_dict: dict[str, Any] = {}
+                try:
+                    raw_entries = json.loads(hb["dict_entries_json"] or "[]")
+                    if isinstance(raw_entries, list):
+                        meta_dict = dict(raw_entries)
+                    elif isinstance(raw_entries, dict):
+                        meta_dict = raw_entries
+                except Exception:
+                    pass
+                htmx_callers.append(
+                    {
+                        "url": url,
+                        "method": hb_method,
+                        "file": hb["file_path"],
+                        "line": hb["line"],
+                        "target": meta_dict.get("target"),
+                        "trigger": meta_dict.get("trigger"),
+                        "swap": meta_dict.get("swap"),
+                        "element": meta_dict.get("element"),
+                    }
+                )
+
+        rendered = template_edges.get(h_canon, []) or template_edges.get(h_name, [])
+
+        lineage: dict[str, Any] = {}
+        try:
+            from codegraph.database.interrogation import get_route_db_lineage
+
+            lineage = get_route_db_lineage(
+                con,
+                route_or_handler=h_canon or h_name or r_path,
+                method=r_method,
+            )
+        except Exception:
+            lineage = {}
+
+        routes.append(
+            {
+                "method": r["http_method"],
+                "path": r["route_path"],
+                "handler": r["handler_canonical_id"] or r["handler_name"],
+                "file": r["file_path"],
+                "start_line": r["line"],
+                "end_line": r["line"],
+                "framework": r["framework"],
+                "htmx_callers": htmx_callers,
+                "templates_rendered": rendered,
+                "db_reads": lineage.get("db_reads", []),
+                "db_writes": lineage.get("db_writes", []),
+                "evidence": make_evidence(
+                    file=r["file_path"],
+                    start_line=r["line"],
+                    end_line=r["line"],
+                    evidence_type="route",
+                    canonical_id=r["handler_canonical_id"],
+                ),
+            }
+        )
 
     total_count = len(routes)
     if limit is not None:

codegraph/lsp.py

@@ -0,0 +1,318 @@
+"""Language Server Protocol (LSP) Bridge for CodeGraph MCP.
+
+Exposes CodeGraph's deterministic, SQLite-backed repository graph as a
+standard Language Server Protocol server (JSON-RPC 2.0 over stdio).
+
+Capabilities:
+- `textDocument/definition`: Jump to definition across Python, TypeScript, and Luau.
+- `textDocument/references`: Find all verified AST callers and references across the repository.
+- `textDocument/codeLens`: Display live caller counts (e.g. `▲ 4 callers`) and remote links above functions.
+- `textDocument/documentSymbol`: Outline symbols in the current file.
+"""
+from __future__ import annotations
+
+import io
+import json
+import sys
+import urllib.parse
+from pathlib import Path
+from typing import Any
+
+from codegraph.indexing.indexer import Indexer
+
+
+def uri_to_path(uri: str) -> Path:
+    """Convert file:// URI to Path."""
+    parsed = urllib.parse.urlparse(uri)
+    if parsed.scheme == "file":
+        path_str = urllib.parse.unquote(parsed.path)
+        # Handle Windows drive letters like /C:/path
+        if sys.platform == "win32" and path_str.startswith("/") and len(path_str) > 2 and path_str[2] == ":":
+            path_str = path_str[1:]
+        return Path(path_str)
+    return Path(uri)
+
+
+def path_to_uri(path: Path | str) -> str:
+    """Convert Path to file:// URI."""
+    p = Path(path).resolve()
+    return p.as_uri()
+
+
+class LSPServer:
+    """Lightweight stdio JSON-RPC Language Server Protocol handler."""
+
+    def __init__(self, repository: Path) -> None:
+        self.repository = repository.resolve()
+        self.indexer = Indexer(self.repository)
+
+    def handle_request(self, method: str, params: dict[str, Any]) -> Any:
+        """Dispatch JSON-RPC request to internal handler."""
+        if method == "initialize":
+            return self._handle_initialize(params)
+        elif method == "textDocument/definition":
+            return self._handle_definition(params)
+        elif method == "textDocument/references":
+            return self._handle_references(params)
+        elif method == "textDocument/codeLens":
+            return self._handle_codelens(params)
+        elif method == "textDocument/documentSymbol":
+            return self._handle_document_symbol(params)
+        elif method == "shutdown":
+            return None
+        return None
+
+    def _handle_initialize(self, params: dict[str, Any]) -> dict[str, Any]:
+        return {
+            "capabilities": {
+                "definitionProvider": True,
+                "referencesProvider": True,
+                "codeLensProvider": {
+                    "resolveProvider": False,
+                },
+                "documentSymbolProvider": True,
+            },
+            "serverInfo": {
+                "name": "codegraph-lsp",
+                "version": "3.0.1",
+            },
+        }
+
+    def _handle_definition(self, params: dict[str, Any]) -> list[dict[str, Any]]:
+        text_doc = params.get("textDocument", {})
+        pos = params.get("position", {})
+        uri = text_doc.get("uri", "")
+        line_0 = pos.get("line", 0)
+        target_line = line_0 + 1
+
+        file_path = str(uri_to_path(uri).relative_to(self.repository)).replace("\\", "/")
+
+        with self.indexer.session() as con:
+            # Check if this line makes a call or reference
+            row = con.execute(
+                """
+                SELECT target, relationship FROM graph_edges
+                WHERE file = ? AND start_line <= ? AND end_line >= ?
+                LIMIT 1
+                """,
+                (file_path, target_line, target_line),
+            ).fetchone()
+
+            if not row:
+                return []
+
+            target_sym = row[0]
+
+            # Find target symbol definition
+            target_def = con.execute(
+                """
+                SELECT path, start_line, end_line
+                FROM symbols
+                WHERE canonical_id = ? OR name = ?
+                LIMIT 1
+                """,
+                (target_sym, target_sym.split(".")[-1]),
+            ).fetchone()
+
+            if not target_def:
+                return []
+
+            def_path = self.repository / target_def[0]
+            start_l = max(0, int(target_def[1]) - 1)
+            end_l = max(0, int(target_def[2]) - 1)
+
+            return [
+                {
+                    "uri": path_to_uri(def_path),
+                    "range": {
+                        "start": {"line": start_l, "character": 0},
+                        "end": {"line": end_l, "character": 0},
+                    },
+                }
+            ]
+
+    def _handle_references(self, params: dict[str, Any]) -> list[dict[str, Any]]:
+        text_doc = params.get("textDocument", {})
+        pos = params.get("position", {})
+        uri = text_doc.get("uri", "")
+        line_0 = pos.get("line", 0)
+        target_line = line_0 + 1
+
+        file_path = str(uri_to_path(uri).relative_to(self.repository)).replace("\\", "/")
+
+        with self.indexer.session() as con:
+            # Find symbol defined or located at position
+            sym_row = con.execute(
+                """
+                SELECT canonical_id, name FROM symbols
+                WHERE path = ? AND start_line <= ? AND end_line >= ?
+                ORDER BY start_line DESC
+                LIMIT 1
+                """,
+                (file_path, target_line, target_line),
+            ).fetchone()
+
+            if not sym_row:
+                return []
+
+            can_id, name = sym_row[0], sym_row[1]
+
+            # Find all callers and references
+            edges = con.execute(
+                """
+                SELECT DISTINCT file, start_line, end_line FROM graph_edges
+                WHERE (target = ? OR target = ?)
+                  AND relationship IN ('CALLS', 'INSTANTIATES', 'IMPORTS', 'REFERENCES')
+                ORDER BY file, start_line
+                LIMIT 50
+                """,
+                (can_id, name),
+            ).fetchall()
+
+            locations: list[dict[str, Any]] = []
+            for f, sl, el in edges:
+                loc_path = self.repository / f
+                locations.append(
+                    {
+                        "uri": path_to_uri(loc_path),
+                        "range": {
+                            "start": {"line": max(0, int(sl) - 1), "character": 0},
+                            "end": {"line": max(0, int(el) - 1), "character": 0},
+                        },
+                    }
+                )
+            return locations
+
+    def _handle_codelens(self, params: dict[str, Any]) -> list[dict[str, Any]]:
+        text_doc = params.get("textDocument", {})
+        uri = text_doc.get("uri", "")
+        file_path = str(uri_to_path(uri).relative_to(self.repository)).replace("\\", "/")
+
+        with self.indexer.session() as con:
+            symbols = con.execute(
+                """
+                SELECT name, canonical_id, kind, start_line, end_line
+                FROM symbols
+                WHERE path = ? AND kind IN ('function', 'method', 'class')
+                """,
+                (file_path,),
+            ).fetchall()
+
+            lenses: list[dict[str, Any]] = []
+            for name, can_id, _kind, start_line, _end_line in symbols:
+                # Count callers
+                caller_count = con.execute(
+                    """
+                    SELECT COUNT(DISTINCT source) FROM graph_edges
+                    WHERE (target = ? OR target = ?)
+                      AND relationship IN ('CALLS', 'INSTANTIATES')
+                    """,
+                    (can_id, name),
+                ).fetchone()[0]
+
+                line_0 = max(0, int(start_line) - 1)
+                lenses.append(
+                    {
+                        "range": {
+                            "start": {"line": line_0, "character": 0},
+                            "end": {"line": line_0, "character": 0},
+                        },
+                        "command": {
+                            "title": f"▲ {caller_count} callers",
+                            "command": "codegraph.showReferences",
+                            "arguments": [uri, {"line": line_0, "character": 0}],
+                        },
+                    }
+                )
+            return lenses
+
+    def _handle_document_symbol(self, params: dict[str, Any]) -> list[dict[str, Any]]:
+        text_doc = params.get("textDocument", {})
+        uri = text_doc.get("uri", "")
+        file_path = str(uri_to_path(uri).relative_to(self.repository)).replace("\\", "/")
+
+        with self.indexer.session() as con:
+            rows = con.execute(
+                """
+                SELECT name, kind, start_line, end_line
+                FROM symbols
+                WHERE path = ?
+                """,
+                (file_path,),
+            ).fetchall()
+
+            kind_mapping = {
+                "function": 12,
+                "method": 6,
+                "class": 5,
+                "variable": 13,
+            }
+
+            symbols: list[dict[str, Any]] = []
+            for name, kind, sl, el in rows:
+                start_l = max(0, int(sl) - 1)
+                end_l = max(0, int(el) - 1)
+                symbols.append(
+                    {
+                        "name": name,
+                        "kind": kind_mapping.get(kind.lower(), 12),
+                        "range": {
+                            "start": {"line": start_l, "character": 0},
+                            "end": {"line": end_l, "character": 0},
+                        },
+                        "selectionRange": {
+                            "start": {"line": start_l, "character": 0},
+                            "end": {"line": start_l, "character": len(name)},
+                        },
+                    }
+                )
+            return symbols
+
+
+def run_stdio_lsp_server(repository: Path, input_stream: io.BufferedReader | None = None, output_stream: io.BufferedWriter | None = None) -> None:
+    """Run JSON-RPC 2.0 LSP server over stdio streams."""
+    server = LSPServer(repository)
+    r = input_stream or sys.stdin.buffer
+    w = output_stream or sys.stdout.buffer
+
+    while True:
+        # Read Content-Length header
+        content_length = 0
+        while True:
+            line = r.readline()
+            if not line:
+                return
+            line_str = line.decode("ascii", errors="replace").strip()
+            if not line_str:
+                break
+            if line_str.lower().startswith("content-length:"):
+                content_length = int(line_str.split(":", 1)[1].strip())
+
+        if content_length <= 0:
+            continue
+
+        body_bytes = r.read(content_length)
+        if not body_bytes:
+            break
+
+        try:
+            req = json.loads(body_bytes.decode("utf-8"))
+        except Exception:
+            continue
+
+        req_id = req.get("id")
+        method = req.get("method", "")
+        params = req.get("params", {})
+
+        result = server.handle_request(method, params)
+
+        if req_id is not None:
+            resp = {
+                "jsonrpc": "2.0",
+                "id": req_id,
+                "result": result,
+            }
+            resp_bytes = json.dumps(resp).encode("utf-8")
+            header = f"Content-Length: {len(resp_bytes)}\r\n\r\n".encode("ascii")
+            w.write(header + resp_bytes)
+            w.flush()

codegraph/lsp_bridge/__init__.py

@@ -0,0 +1,16 @@
+"""Language Server Protocol (LSP) Bridge for CodeGraph."""
+from __future__ import annotations
+
+from .bridge import collect_lsp_diagnostics, detect_lsp_servers
+from .client import LSPClient
+from .models import DiagnosticSeverity, LSPBridgeReport, LSPDiagnostic, LSPLocation
+
+__all__ = [
+    "DiagnosticSeverity",
+    "LSPBridgeReport",
+    "LSPClient",
+    "LSPDiagnostic",
+    "LSPLocation",
+    "collect_lsp_diagnostics",
+    "detect_lsp_servers",
+]