codecortex 0.2.0__py3-none-any.whl

codeintel/cache.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import hashlib
+import os
+import threading
+from typing import Optional
+
+from codeintel.provider import Result
+
+
+def _compute_hash(target: str, project_root: str) -> str:
+    try:
+        root = os.path.realpath(project_root) if project_root else ""
+        path = os.path.realpath(target)
+        if root and path.startswith(root + os.sep) or path == root:
+            if os.path.isfile(path):
+                with open(path, "rb") as fh:
+                    return hashlib.sha256(fh.read()).hexdigest()
+    except Exception:
+        pass
+    return hashlib.sha256(target.encode()).hexdigest()
+
+
+class ContentHashCache:
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        # key → (content_hash, Result)
+        self._store: dict[tuple[str, str, str, str], tuple[str, Result]] = {}
+
+    def get(
+        self,
+        op: str,
+        target: str,
+        engine: str,
+        project_root: str,
+        freshness: int = 0,
+    ) -> Optional[Result]:
+        key = (op, target, engine, project_root)
+        with self._lock:
+            entry = self._store.get(key)
+        if entry is None:
+            return None
+        stored_hash, result = entry
+        current_hash = f"{_compute_hash(target, project_root)}:{freshness}"
+        if current_hash == stored_hash:
+            return result
+        return None
+
+    def put(
+        self,
+        op: str,
+        target: str,
+        engine: str,
+        project_root: str,
+        result: Optional[Result],
+        freshness: int = 0,
+    ) -> None:
+        if result is None or result.get("result") is None:
+            return
+        key = (op, target, engine, project_root)
+        # Fold the project's index generation into the stored hash so a completed reindex
+        # (which bumps `freshness`) forces a refresh even when the target isn't a file whose
+        # content hash would change — i.e. every symbol/free-text query.
+        content_hash = f"{_compute_hash(target, project_root)}:{freshness}"
+        with self._lock:
+            self._store[key] = (content_hash, result)

codeintel/config.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import pathlib
+import sys
+
+if sys.version_info >= (3, 11):
+    import tomllib
+else:  # pragma: no cover
+    try:
+        import tomllib  # type: ignore[no-redef]
+    except ImportError:
+        import tomli as tomllib  # type: ignore[no-redef]
+
+_DEFAULTS: dict = {
+    "backend": "auto",
+    "semantic": "on",
+    "reindex": "on-demand",
+    "window": 20,
+    "stride": 10,
+    "max_chunks": 500,
+    "cosine_floor": 0.25,
+    "model": "BAAI/bge-small-en-v1.5",
+}
+
+
+def _read_toml(path: pathlib.Path) -> dict:
+    try:
+        with path.open("rb") as fh:
+            return tomllib.load(fh)
+    except (FileNotFoundError, OSError, tomllib.TOMLDecodeError):
+        return {}
+
+
+def load_config(project_root: str | None = None) -> dict:
+    """Return merged config: defaults < global < project."""
+    root = pathlib.Path(project_root) if project_root is not None else pathlib.Path.cwd()
+
+    global_cfg = _read_toml(pathlib.Path.home() / ".codeintel" / "config.toml")
+    project_cfg = _read_toml(root / ".codeintel.toml")
+
+    merged = {**_DEFAULTS, **global_cfg, **project_cfg}
+    return merged

codeintel/doctor.py

@@ -0,0 +1,161 @@
+"""Preflight diagnostics — turn the tool's silent safe-null degradation into a clear signal.
+
+`run_doctor` asks each engine three questions — installed? runnable? is THIS repo indexed? —
+with a one-line remediation per gap. It is never-raise and bounded: no engine check may hang,
+crash, load the embedding model, mutate state, or go through the gateway (no reindex side
+effects). The same report drives the CLI `doctor` command, the `code.doctor` MCP tool, and HTTP.
+"""
+from __future__ import annotations
+
+import os
+from typing import Any, Callable, Optional
+
+_ENGINES = ("graph", "lsp", "semantic")
+
+
+def _status_for(report: dict) -> str:
+    """Roll a probe dict up to ok / warn / fail.
+
+    fail = not installed, not runnable, or (graph/semantic) repo not indexed — all actionable.
+    warn = installed but readiness unknown (lsp not-yet-warmed, or a deep boot that timed out).
+    ok   = installed, runnable, and (where applicable) this repo is indexed."""
+    if not report.get("installed"):
+        return "fail"
+    runnable = report.get("runnable")
+    if runnable is False:
+        return "fail"
+    if report.get("repo_indexed") is False:
+        return "fail"
+    if runnable is None:
+        return "warn"
+    return "ok"
+
+
+def _probe_engine(
+    engine: str,
+    provider: Any,
+    build: Callable[[], Any],
+    call: Callable[[Any], dict],
+) -> dict:
+    """Run one engine's probe, never raising. Uses the passed-in (live) provider when given,
+    else builds an ephemeral one."""
+    try:
+        p = provider if provider is not None else build()
+    except Exception as exc:
+        r = {"installed": False, "runnable": False, "repo_indexed": None,
+             "detail": f"could not construct provider ({type(exc).__name__})", "remediation": None}
+        return {"engine": engine, "status": "fail", **r}
+    try:
+        r = dict(call(p) or {})
+    except Exception as exc:
+        r = {"installed": None, "runnable": False, "repo_indexed": None,
+             "detail": f"probe raised ({type(exc).__name__})", "remediation": None}
+    r["engine"] = engine
+    r["status"] = _status_for(r)
+    return r
+
+
+def run_doctor(
+    project_root: Any,
+    *,
+    deep: bool = False,
+    graph: Any = None,
+    lsp: Any = None,
+    semantic: Any = None,
+    lsp_deep_timeout_s: float = 20.0,
+) -> dict:
+    """Diagnose all three engines for ``project_root``. Never raises; bounded (~3s shallow).
+
+    Pass live providers (e.g. the singleton gateway's) to reflect real warmed state; omit them
+    for a hermetic check that builds fresh providers."""
+    try:
+        root = os.path.abspath(str(project_root)) if project_root else os.getcwd()
+    except Exception:
+        root = str(project_root or "")
+
+    engines: dict[str, dict] = {}
+    try:
+        from codeintel.providers.graph import GraphProvider
+        engines["graph"] = _probe_engine(
+            "graph", graph, GraphProvider, lambda p: p.probe(root)
+        )
+    except Exception:
+        engines["graph"] = {"engine": "graph", "status": "fail", "installed": False,
+                            "runnable": False, "repo_indexed": None,
+                            "detail": "graph provider unavailable", "remediation": None}
+    try:
+        from codeintel.providers.lsp import LspProvider
+        engines["lsp"] = _probe_engine(
+            "lsp", lsp, LspProvider, lambda p: p.probe(root, deep=deep, timeout_s=lsp_deep_timeout_s)
+        )
+    except Exception:
+        engines["lsp"] = {"engine": "lsp", "status": "fail", "installed": False,
+                         "runnable": False, "repo_indexed": None,
+                         "detail": "lsp provider unavailable", "remediation": None}
+    try:
+        from codeintel.providers.semantic import SemanticProvider
+        engines["semantic"] = _probe_engine(
+            "semantic", semantic, SemanticProvider, lambda p: p.probe(root)
+        )
+    except Exception:
+        engines["semantic"] = {"engine": "semantic", "status": "fail", "installed": False,
+                              "runnable": False, "repo_indexed": None,
+                              "detail": "semantic provider unavailable", "remediation": None}
+
+    ready = sum(1 for e in engines.values() if e.get("status") != "fail")
+    return {
+        "ok": True,
+        "project_root": root,
+        "deep": bool(deep),
+        "summary": {"ready": ready, "total": len(engines),
+                    "healthy": all(e.get("status") != "fail" for e in engines.values())},
+        "engines": engines,
+    }
+
+
+def render_doctor_text(report: dict) -> str:
+    """Human-readable CLI rendering: a per-engine ✓/✗/▲ table + two-line `fix:` remediation.
+    Styled via codeintel.term (color only on a TTY; width-safe glyphs so columns stay aligned)."""
+    from codeintel.term import c  # imported at call time to honor the CLI's term.configure()
+
+    _NAME, _INST, _RUN, _REPO = 10, 11, 10, 14
+    root = report.get("project_root", "")
+    engines = report.get("engines", {})
+    out = [c.header("doctor", root), ""]
+    out.append("  " + c.bold(
+        "engine".ljust(_NAME) + " " + "installed".center(_INST) + " "
+        + "runnable".center(_RUN) + " " + "repo-indexed".center(_REPO)
+    ))
+    out.append("  " + c.rule(_NAME) + " " + c.rule(_INST) + " " + c.rule(_RUN) + " " + c.rule(_REPO))
+
+    def _state(value, na_ok=False):
+        if value is True:
+            return "ok"
+        if value is False:
+            return "fail"
+        return "na" if na_ok else "warn"
+
+    notes: list[tuple] = []
+    for name in _ENGINES:
+        e = engines.get(name, {})
+        inst = c.status_cell(_state(e.get("installed")), _INST)
+        run = c.status_cell(_state(e.get("runnable")), _RUN)
+        repo = c.status_cell(_state(e.get("repo_indexed"), na_ok=True), _REPO)
+        out.append("  " + name.ljust(_NAME) + " " + inst + " " + run + " " + repo)
+        if e.get("status") != "ok":
+            notes.append((name, e.get("detail", ""), e.get("remediation")))
+
+    for name, detail, rem in notes:
+        out.append("")
+        out.append("  " + c.dim("└─") + " " + c.cyan(name) + ": " + detail)
+        if rem:
+            out.append("     " + c.bold(c.cyan("fix:")) + " " + rem)
+
+    summ = report.get("summary", {})
+    ready, total, healthy = summ.get("ready", "?"), summ.get("total", "?"), summ.get("healthy")
+    count = c.bold(f"{ready} / {total}")
+    count = c.red(count) if healthy is False else (c.green(count) if healthy else count)
+    tail = "" if report.get("deep") else c.dim("  (run with --deep to boot-check serena)")
+    out.append("")
+    out.append(f"  {count} engines ready for this repo.{tail}")
+    return "\n".join(out)

codeintel/gateway.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from typing import Any
+
+from codeintel.cache import ContentHashCache
+from codeintel.policy import TieringPolicy
+from codeintel.provider import Result, safe_null_result
+from codeintel.providers.none import NoneProvider
+from codeintel.reindexer import Reindexer
+
+_KNOWN_ENGINES: frozenset[str] = frozenset({"graph", "lsp", "semantic", "auto", "both", "all"})
+_FANOUT_ENGINES: frozenset[str] = frozenset({"both", "all"})
+
+# op → preferred single engine for auto-dispatch
+_AUTO_ENGINE: dict[str, str] = {
+    "impact": "graph",
+    "callers": "graph",
+    "callees": "graph",
+    "chain": "graph",
+    "pattern": "graph",
+    "overview": "graph",
+    "symbol": "lsp",
+    "search": "semantic",
+    "context": "both",  # fan-out; resolved in Phase 4
+}
+
+
+class Gateway:
+    def __init__(self, graph=None, lsp=None, semantic=None, policy: TieringPolicy | None = None, reindexer: Reindexer | None = None):
+        # Backward-compat: old tests pass a list as the first positional arg.
+        if isinstance(graph, list):
+            self._legacy_providers: list | None = graph
+            self.graph = None
+            self.lsp = None
+            self.semantic = None
+        else:
+            self._legacy_providers = None
+            self.graph = graph
+            self.lsp = lsp
+            self.semantic = semantic
+        self._none = NoneProvider()
+        self._cache = ContentHashCache()
+        self._policy = policy
+        self._reindexer = reindexer or Reindexer()
+
+    def _provider_for(self, engine_str: str):
+        if engine_str == "graph":
+            return self.graph
+        if engine_str == "lsp":
+            return self.lsp
+        if engine_str == "semantic":
+            return self.semantic
+        return None
+
+    def _fan_out(
+        self,
+        engines: list[str],
+        op_str: str,
+        target_str: str,
+        budget: Any,
+        project_root: Any,
+    ) -> dict[str, Result]:
+        def _call(engine_str: str) -> tuple[str, Result]:
+            provider = self._provider_for(engine_str)
+            return engine_str, self._dispatch_single(
+                provider, op_str, target_str, budget, project_root, engine_str
+            )
+
+        results: dict[str, Result] = {}
+        try:
+            with ThreadPoolExecutor(max_workers=3) as executor:
+                futures = {executor.submit(_call, e): e for e in engines}
+                for future in as_completed(futures):
+                    try:
+                        engine_str, result = future.result()
+                        results[engine_str] = result
+                    except Exception:
+                        engine_str = futures[future]
+                        results[engine_str] = safe_null_result(
+                            op_str, target_str, engine=engine_str, reason="provider-error"
+                        )
+        except Exception:
+            for e in engines:
+                if e not in results:
+                    results[e] = safe_null_result(op_str, target_str, engine=e, reason="provider-error")
+        return results
+
+    def _merge(
+        self,
+        results: dict[str, Result],
+        op_str: str,
+        target_str: str,
+        engine_str: str = "merged",
+    ) -> Result:
+        parts: list[str] = []
+        for eng, r in results.items():
+            if r.get("result") is not None:
+                parts.append(f"## [{eng}]\n{r['result']}")
+
+        if not parts:
+            return safe_null_result(op_str, target_str, engine=engine_str, reason="no-result")
+
+        return {
+            "ok": True,
+            "op": op_str,
+            "target": target_str,
+            "result": "\n\n".join(parts),
+            "engine": engine_str,
+            "cached": False,
+        }
+
+    def _dispatch_single(
+        self,
+        provider,
+        op_str: str,
+        target_str: str,
+        budget,
+        project_root,
+        engine_str: str,
+    ) -> Result:
+        if provider is None:
+            return safe_null_result(op_str, target_str, engine=engine_str, reason="engine-unavailable")
+        if not getattr(provider, "available", True):
+            return safe_null_result(op_str, target_str, engine=engine_str, reason="engine-unavailable")
+        try:
+            r = provider.build_result(op_str, target_str, [], budget or 0, project_root or "")
+            if r is not None:
+                return r
+            return safe_null_result(op_str, target_str, engine=engine_str, reason="no-result")
+        except Exception:
+            return safe_null_result(op_str, target_str, engine=engine_str, reason="provider-error")
+
+    def query(
+        self,
+        op=None,
+        target=None,
+        engine=None,
+        role: str = "",
+        budget=None,
+        project_root=None,
+    ) -> Result:
+        try:
+            try:
+                self._reindexer.maybe_reindex(str(project_root or ""))
+            except Exception:
+                pass
+
+            op_str = str(op or "")
+            target_str = str(target or "")
+            engine_str = str(engine or "").strip() or "auto"
+            was_auto = engine_str == "auto"
+
+            # Legacy list-based path (backward compat with pre-Phase-2 tests)
+            if self._legacy_providers is not None:
+                for p in self._legacy_providers:
+                    try:
+                        r = p.build_result(op_str, target_str, [], budget or 0, project_root or "")
+                        if r is not None:
+                            return r
+                    except Exception:
+                        continue
+                reason = "engine-unavailable" if engine is not None else "no-result"
+                return safe_null_result(op_str, target_str, reason=reason)
+
+            # Policy check — before cache lookup
+            if self._policy is not None and not self._policy.is_allowed(role, op_str):
+                return safe_null_result(op_str, target_str, reason="op-not-allowed-for-role")
+
+            # Unknown engine — reject immediately
+            if engine_str not in _KNOWN_ENGINES:
+                return safe_null_result(op_str, target_str, reason="unknown-engine")
+
+            # Auto: resolve by op
+            if engine_str == "auto":
+                engine_str = _AUTO_ENGINE.get(op_str, "graph")
+
+            root_str = project_root or ""
+
+            # Freshness token — bumps when a background reindex completes, so a cached
+            # structural answer (a symbol/free-text target, whose content hash never
+            # changes) is invalidated once the index actually moves. 0 when unavailable.
+            try:
+                freshness = self._reindexer.generation(root_str)
+            except Exception:
+                freshness = 0
+
+            # Fan-out: dispatch to multiple engines concurrently and merge
+            if engine_str in _FANOUT_ENGINES:
+                cached_result = self._cache.get(op_str, target_str, engine_str, root_str, freshness)
+                if cached_result is not None:
+                    return {**cached_result, "cached": True}
+                if engine_str == "both":
+                    engines = ["graph", "lsp"]
+                else:  # "all"
+                    engines = ["graph", "lsp", "semantic"]
+                fan_results = self._fan_out(engines, op_str, target_str, budget, project_root)
+                result = self._merge(fan_results, op_str, target_str, engine_str)
+                self._cache.put(op_str, target_str, engine_str, root_str, result, freshness)
+                return result
+
+            # Single-engine dispatch
+            cached_result = self._cache.get(op_str, target_str, engine_str, root_str, freshness)
+            if cached_result is not None:
+                return {**cached_result, "cached": True}
+            provider = self._provider_for(engine_str)
+            result = self._dispatch_single(provider, op_str, target_str, budget, project_root, engine_str)
+
+            # overview auto-fallback (F4 Story 2): when auto-routed to graph but graph is
+            # unavailable, try lsp — a file/symbol overview is something lsp can also serve.
+            if (
+                was_auto
+                and op_str == "overview"
+                and engine_str == "graph"
+                and result.get("result") is None
+                and result.get("reason") == "engine-unavailable"
+            ):
+                lsp_result = self._dispatch_single(
+                    self.lsp, op_str, target_str, budget, project_root, "lsp"
+                )
+                if lsp_result.get("result") is not None:
+                    result = lsp_result
+
+            self._cache.put(op_str, target_str, engine_str, root_str, result, freshness)
+            return result
+
+        except Exception:
+            return safe_null_result(op or "", target or "", reason="gateway-error")

codeintel/http_server.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+import sys
+from http.server import BaseHTTPRequestHandler, HTTPServer
+
+from codeintel.server import code_doctor_handler, code_query_handler, code_status_handler
+
+_MAX_BODY_BYTES = 1_048_576  # 1 MiB
+
+
+class _Handler(BaseHTTPRequestHandler):
+    def log_message(self, format: str, *args: object) -> None:
+        pass  # suppress default stderr noise
+
+    def _send_json(self, status: int, data: dict) -> None:
+        body = json.dumps(data).encode()
+        self.send_response(status)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Content-Length", str(len(body)))
+        self.end_headers()
+        self.wfile.write(body)
+
+    def do_POST(self) -> None:
+        if self.path not in ("/code/query", "/code/doctor"):
+            self._send_json(404, {"error": "not-found"})
+            return
+        try:
+            content_length = int(self.headers.get("Content-Length", 0))
+        except (TypeError, ValueError):
+            self._send_json(400, {"error": "bad-request"})
+            return
+        if content_length > _MAX_BODY_BYTES:
+            self.close_connection = True          # do not read the oversized body
+            self._send_json(413, {"error": "payload-too-large", "max_bytes": _MAX_BODY_BYTES})
+            return
+        raw = self.rfile.read(content_length) if content_length > 0 else b""
+        try:
+            parsed = json.loads(raw)
+        except (json.JSONDecodeError, ValueError):
+            self._send_json(400, {"error": "bad-request"})
+            return
+        if not isinstance(parsed, dict):
+            self._send_json(400, {"error": "bad-request"})
+            return
+        if self.path == "/code/doctor":
+            result = code_doctor_handler(parsed)
+        else:
+            result = code_query_handler(parsed)
+        self._send_json(200, result)
+
+    def do_GET(self) -> None:
+        if self.path != "/code/status":
+            self._send_json(404, {"error": "not-found"})
+            return
+        result = code_status_handler({})
+        self._send_json(200, result)
+
+
+class CodeIntelHTTPServer(HTTPServer):
+    pass
+
+
+_LOOPBACK_NAMES = {"localhost"}
+
+
+def _is_loopback(host: str) -> bool:
+    # Treat as loopback ONLY: the literal name "localhost", or an IP literal in a loopback range
+    # (127.0.0.0/8, ::1). A string-prefix test like host.startswith("127.") is unsafe — it would
+    # accept an attacker-controlled HOSTNAME such as "127.0.0.1.evil.example", bypassing the guard.
+    import ipaddress
+
+    h = (host or "").strip().lower()
+    if h in _LOOPBACK_NAMES:
+        return True
+    try:
+        return ipaddress.ip_address(h).is_loopback
+    except ValueError:
+        return False  # a non-IP hostname is never treated as loopback
+
+
+def run(host: str = "127.0.0.1", port: int = 8766, *, allow_remote: bool = False) -> None:
+    if not _is_loopback(host) and not allow_remote:
+        print(f"refusing to bind non-loopback host {host!r} without --allow-remote — this would "
+              f"expose an UNAUTHENTICATED code-intel endpoint (your indexed repo) to the network",
+              file=sys.stderr)
+        raise SystemExit(2)
+    if not _is_loopback(host):
+        print(f"WARNING: serving codeintel on {host}:{port} with NO authentication — anyone who can "
+              f"reach this port can read your indexed repo", file=sys.stderr)
+    server = CodeIntelHTTPServer((host, port), _Handler)
+    print(f"Listening on http://{host}:{port}")
+    server.serve_forever()