better-code-review-graph 3.26.26__tar.gz → 3.27.0__tar.gz

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "better-code-review-graph",
   "description": "Knowledge graph for token-efficient code reviews -- semantic search and call-graph resolution across your codebase.",
-  "version": "3.26.26",
+  "version": "3.27.0",
   "userConfig": {
     "EMBEDDING_MODELS": {
       "type": "string",

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/CHANGELOG.md

@@ -2,6 +2,33 @@
 
 <!-- version list -->
 
+## v3.27.0 (2026-09-26)
+
+### Bug Fixes
+
+- **migrations**: 005 skip git guard for per-subject data-dir stores
+  ([`5944956`](https://github.com/n24q02m/crg/commit/5944956259acd70ce76d02dd160587dbb9fa832c))
+
+- **server**: Drop dead _maybe_include_setup_hint hook (BYOK cut residual)
+  ([`87c9ce4`](https://github.com/n24q02m/crg/commit/87c9ce454501aaa2ec39373f3731739ae7247054))
+
+- **server,tools**: Remove deleted-member imports on search/setup/http paths
+  ([`edc7b5f`](https://github.com/n24q02m/crg/commit/edc7b5f24d61bd1cf8eec1089396e269750694ab))
+
+- **wp2**: Drop mcp-core entirely; port residual tests to hull seams
+  ([`91b1ddb`](https://github.com/n24q02m/crg/commit/91b1ddb20ca4957ef32bbf40b478c01a8419a5a7))
+
+### Features
+
+- **wp2**: De-host onto hull-core — auth scoping, model cells, config bridge
+  ([`0683c62`](https://github.com/n24q02m/crg/commit/0683c62d88fbaf11aa8666a3adcf21cd357c9a63))
+
+### Testing
+
+- Port suite to the post-de-host surface (hull cells, no litellm/relay)
+  ([`fd7795d`](https://github.com/n24q02m/crg/commit/fd7795da0f3ac268430e5d22cbef4756a2120f0d))
+
+
 ## v3.26.26 (2026-09-25)
 
 ### Bug Fixes

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: better-code-review-graph
-Version: 3.26.26
+Version: 3.27.0
 Summary: Token-efficient code review knowledge graph: semantic search and call-graph resolution.
 Author: n24q02m
 License-Expression: Apache-2.0
@@ -18,9 +18,8 @@ Requires-Dist: defusedxml>=0.7.1
 Requires-Dist: fastmcp<4,>=3.4.7
 Requires-Dist: fastretrieval<2,>=1.8.2
 Requires-Dist: httpx
-Requires-Dist: litellm>=1.102.0
+Requires-Dist: hull-core
 Requires-Dist: mcp<2,>=1.30.0
-Requires-Dist: n24q02m-mcp-core[llm]==1.24.6
 Requires-Dist: networkx<4,>=3.7
 Requires-Dist: pydantic-settings
 Requires-Dist: pygments>=2.21.0

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/migrations/versions/005_temporal_columns.py

@@ -118,6 +118,15 @@ _SHA_RE = re.compile(r"^[0-9a-f]{40}$|^[0-9a-f]{64}$")
 #    git-init its own tmp dir, which conflicts with tests that
 #    construct ``tmp_path / ".git"`` themselves.
 #
+# 3. The DB is a per-subject store under the crg data directory
+#    (``<CRG_DATA_DIR>/subs/<sub>/graph.db``, ``~/.crg`` default).
+#    Multi-user (hull mode-3) deployments scope each namespace's
+#    graph to its own data-directory DB precisely so it does NOT
+#    live inside any analyzed repo — there is no single HEAD to
+#    backfill with, so the sentinel is the correct value. Repo
+#    stores (``<repo>/.better-code-review-graph/graph.db``) still
+#    require git.
+#
 # Production code paths leave ``CRG_TEST_ALLOW_NO_GIT`` unset, so the
 # migration still aborts with the actionable :class:`RuntimeError`
 # whenever a file-backed DB has no reachable repo — production data
@@ -152,6 +161,35 @@ def _extract_db_path_from_url(url: str) -> Path | None:
     return Path(raw).resolve()
 
 
+def _data_dir_subs_base() -> Path:
+    """Return the resolved ``subs`` root of the crg data directory.
+
+    Mirrors ``credential_state._sub_data_dir``: ``$CRG_DATA_DIR`` when
+    set, otherwise ``~/.crg``. Per-subject stores (multi-user HTTP
+    mode) live at ``<base>/subs/<sub>/graph.db`` under this root.
+    """
+    base = Path(os.environ.get("CRG_DATA_DIR", str(Path.home() / ".crg")))
+    return (base / "subs").resolve()
+
+
+def _is_data_dir_store(db_path: Path) -> bool:
+    """True iff ``db_path`` is a per-subject store under the crg data dir.
+
+    Multi-user (hull mode-3) deployments scope each namespace's graph to
+    ``<CRG_DATA_DIR>/subs/<sub>/graph.db`` — a data-directory DB that
+    intentionally does NOT live inside any analyzed repo (the analyzed
+    repo directory is not a safe shared location for a per-tenant DB).
+    Such a store has no single HEAD to backfill ``valid_from_sha``
+    with, so the 40-zero sentinel applies. Repo stores
+    (``<repo>/.better-code-review-graph/graph.db``) keep the hard git
+    requirement enforced by :func:`_find_repo_root`.
+    """
+    try:
+        return db_path.resolve().is_relative_to(_data_dir_subs_base())
+    except (OSError, ValueError):
+        return False
+
+
 def _find_repo_root(db_path: Path) -> Path:
     """Walk parents of ``db_path`` looking for a ``.git`` entry.
 
@@ -291,7 +329,10 @@ def _resolve_head_sha() -> str:
       process so the value is only the DDL default for transient tests, OR
     * the file-backed DB has no reachable ``.git`` ancestor AND the
       operator has opted in to the test-only escape hatch via
-      ``CRG_TEST_ALLOW_NO_GIT=1``.
+      ``CRG_TEST_ALLOW_NO_GIT=1``, OR
+    * the DB is a per-subject store under the crg data directory
+      (``<CRG_DATA_DIR>/subs/<sub>/graph.db``) — a data-directory DB
+      intentionally outside every repo, so there is no HEAD to read.
 
     File-backed DBs without a reachable ``.git`` ancestor and without
     the test escape hatch still raise the actionable
@@ -307,6 +348,8 @@ def _resolve_head_sha() -> str:
     db_path = _extract_db_path_from_url(url)
     if db_path is None:
         return _IN_MEMORY_SENTINEL_SHA
+    if _is_data_dir_store(db_path):
+        return _IN_MEMORY_SENTINEL_SHA
     try:
         repo_root = _find_repo_root(db_path)
         return _read_head_sha(repo_root)

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "better-code-review-graph"
-version = "3.26.26"
+version = "3.27.0"
 description = "Token-efficient code review knowledge graph: semantic search and call-graph resolution."
 readme = { file = "README.md", content-type = "text/markdown" }
 license = "Apache-2.0"
@@ -27,27 +27,19 @@ dependencies = [
     "fastretrieval>=1.8.2,<2",
     "httpx",
     "pydantic-settings",
-    # Floor tracks the current mcp-core stable for cascade parity with
-    # wet/mnemo. Carries the build_cli `config`/`doctor` PerPluginStore key
-    # fix (#666) for servers whose plugin slug differs from server_name
-    # (this repo's slug == server_name already, so no CLI regression here).
-    # Keep this on a stable release -- a prerelease floor such as 1.20.0b2
-    # sorts below its own stable under PEP 440 and does not require it.
-    "n24q02m-mcp-core[llm]==1.24.6",
-    # litellm security floor (transitive via mcp-core[llm]). 1.83.x-1.87.x carry 4
-    # advisories in litellm's PROXY server: GHSA-r75f-5x8p-qvmc (SQLi in proxy key
-    # verify), GHSA-xqmj-j6mv-4862 (SSTI /prompts/test), GHSA-v4p8-mg3p-g94g (cmd-exec
-    # proxy MCP endpoints), GHSA-wxxx-gvqv-xp7p (sandbox escape custom-code guardrail).
-    # We use litellm LIBRARY mode only (no proxy) so none are in our attack surface,
-    # but Dependency Review flags the package version. 1.88.0+ clears all four.
-    # crg's optional semgrep extra otherwise pins the resolver to litellm 1.83.0; this
-    # floor lifts it (semgrep resolves to 1.79.x, fine for a dev-only SAST tool).
-    "litellm>=1.102.0",
+    # De-hosted shared core (WP1): token auth (3 modes), per-task model cells
+    # (plain-HTTP OpenAI-spec, no litellm), server lifecycle lock. Vendored via
+    # git because hull-core is not published to PyPI (spec 2026-09-26 §3);
+    # rev pins the WP1-verified hull commit.
+    "hull-core",
     "Pygments>=2.21.0",
     "alembic>=1.20.0,<2",
     "defusedxml>=0.7.1",
 ]
 
+[tool.uv.sources]
+hull-core = { git = "https://github.com/n24q02m/hull", subdirectory = "packages/core-py", rev = "5262d54f4f0c1214dcedaef20531da98f9519bdf" }
+
 [project.scripts]
 better-code-review-graph = "better_code_review_graph.cli:main"
 crg = "better_code_review_graph.cli:main"

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/server.json

@@ -6,12 +6,12 @@
     "url": "https://github.com/n24q02m/crg.git",
     "source": "github"
   },
-  "version": "3.26.26",
+  "version": "3.27.0",
   "packages": [
     {
       "registryType": "pypi",
       "identifier": "better-code-review-graph",
-      "version": "3.26.26",
+      "version": "3.27.0",
       "runtimeHint": "uvx",
       "runtimeArgs": [
         "--python",

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/src/better_code_review_graph/cli.py

@@ -1,8 +1,8 @@
-"""Console-script entry: mounts the shared mcp_core CLI builder.
+"""Console-script entry: local argparse dispatch (de-hosted, no shared core).
 
-Bare invocation and any leading-dash argv (e.g. --http) start the server
-exactly as before; a leading positional argv[0] routes to a subcommand
-(``graph``, ``query``, ``review``, ``security``, etc.) instead.
+Bare invocation and any leading-dash argv (e.g. --http) start the server;
+a leading positional argv[0] routes to a subcommand (``graph``, ``query``,
+``review``, ``security``) instead of the server.
 """
 
 from __future__ import annotations
@@ -519,19 +519,61 @@ def _handle_security(args: argparse.Namespace) -> int:
 
 
 def main() -> int:
-    from mcp_core import build_cli
-
-    return build_cli(
-        "better-code-review-graph",
-        serve=_serve,
-        extra={
-            "graph": (_configure_graph, _handle_graph),
-            "query": (_configure_query, _handle_query),
-            "review": (_configure_review, _handle_review),
-            "security": (_configure_security, _handle_security),
-        },
-        version=_version(),
-    )(None)
+    """Route argv: server start vs. local subcommands.
+
+    Same dispatch contract the shared core builder used to provide, now
+    local: bare or leading-dash argv goes to the server (``_serve``), a
+    known leading subcommand is parsed by its own argparse subparser and
+    handed to its handler, anything else is a clean rc-2 usage error.
+    """
+    import sys
+
+    handlers: dict[str, tuple[Any, Any]] = {
+        "graph": (_configure_graph, _handle_graph),
+        "query": (_configure_query, _handle_query),
+        "review": (_configure_review, _handle_review),
+        "security": (_configure_security, _handle_security),
+    }
+
+    argv = sys.argv[1:]
+    if not argv:
+        rc = _serve([])
+        return 0 if rc is None else rc
+
+    # Intercept bare flags before argparse: -h/--help/--version must print
+    # and exit instead of starting (and blocking on) the stdio server, and
+    # any other leading dash is passed through to the server untouched.
+    if argv[0] in ("-h", "--help"):
+        names = ", ".join(sorted(handlers))
+        print("usage: better-code-review-graph [-h] [--version] [<subcommand> ...]")
+        print("Any other flags/args are passed through to the MCP server (e.g. --http).")
+        print(f"subcommands: {names}")
+        return 0
+    if argv[0] in ("--version", "-V"):
+        print(f"better-code-review-graph {_version()}")
+        return 0
+    if argv[0].startswith("-"):
+        rc = _serve(argv)
+        return 0 if rc is None else rc
+
+    spec = handlers.get(argv[0])
+    if spec is None:
+        names = ", ".join(sorted(handlers))
+        print(
+            f"better-code-review-graph: unknown subcommand {argv[0]!r} "
+            f"(expected one of: {names})",
+            file=sys.stderr,
+        )
+        return 2
+
+    configure_fn, handler_fn = spec
+    parser = argparse.ArgumentParser(prog="better-code-review-graph")
+    subparsers = parser.add_subparsers(dest="subcommand")
+    sub = subparsers.add_parser(argv[0])
+    if configure_fn is not None:
+        configure_fn(sub)
+    ns = parser.parse_args(argv)
+    return handler_fn(ns)
 
 
 if __name__ == "__main__":

{better_code_review_graph-3.26.26 → better_code_review_graph-3.27.0}/src/better_code_review_graph/config.py

@@ -1,7 +1,11 @@
 """Cấu hình cho backend embedding cục bộ của CRG."""
 
+import os
+from pathlib import Path
 from typing import Any
 
+from hull_core.config.models import ModelCell, resolve_model_cells
+from hull_core.config.settings import HullSettings, load_settings
 from pydantic import model_validator
 from pydantic_settings import BaseSettings
 
@@ -44,3 +48,32 @@ class Settings(BaseSettings):
 
 
 settings = Settings()
+
+
+# ---------------------------------------------------------------------------
+# Hull-core instance config (WP2 de-host, spec 2026-09-26 §3/§4)
+# ---------------------------------------------------------------------------
+
+
+def crg_config_dir() -> Path:
+    """Host-owned instance config directory: ``$CRG_CONFIG_DIR`` or ``~/.crg``.
+
+    Same schema as hull's ``config.toml``: ``[server]`` (bind, auth mode,
+    users file) + per-task ``[models.<task>]`` provider cells. Keys live
+    here (or arrive via ``HULL_<TASK>_API_KEY`` env) — they are host-only
+    material and never end-user supplied (spec §4 Q1, BYOK cut).
+    """
+    return Path(os.environ.get("CRG_CONFIG_DIR") or Path.home() / ".crg")
+
+
+def load_instance_settings() -> HullSettings:
+    """Load the crg instance config through hull-core's loader."""
+    return load_settings(crg_config_dir())
+
+
+def resolve_cells(
+    settings: HullSettings | None = None, env: dict[str, str] | None = None
+) -> dict[str, ModelCell]:
+    """Resolve the per-task provider cells (embed / rerank / chat / jev_score)."""
+    settings = settings if settings is not None else load_instance_settings()
+    return resolve_model_cells(settings.models, env=env)

better_code_review_graph-3.27.0/src/better_code_review_graph/credential_state.py

@@ -0,0 +1,160 @@
+"""Per-request subject scoping and per-sub data paths.
+
+De-hosted (WP2, spec 2026-09-26 §4): authentication is hull-core's token
+middleware with three config modes (no-auth / token / multi, ``users.toml``).
+There is no credential store, no browser setup flow, and no per-user key
+bucket —
+provider keys are host-only material configured in the instance
+``config.toml`` ``[models.*]`` cells (or ``HULL_<TASK>_API_KEY`` env); the
+end user never sees or submits them (BYOK cut).
+
+What remains here is the data-isolation half: in auth mode ``multi`` the
+authenticated user's namespace scopes the graph database at
+``subs/<namespace>/graph.db`` under ``CRG_DATA_DIR`` so concurrent users on
+one process never see each other's graph. Modes no-auth/token keep one
+shared namespace and therefore the repo-local ``graph.db`` (same file the
+CLI uses — host indexing and serving stay consistent).
+"""
+
+from __future__ import annotations
+
+import contextvars
+import logging
+import os
+from enum import Enum
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+SERVER_NAME = "better-code-review-graph"
+
+
+class CredentialState(Enum):
+    CONFIGURED = "configured"  # at least one per-task model cell has a key
+    LOCAL = "local"  # no cloud cells configured; local ONNX fallback serves
+
+
+# Module-level state (host-level; never per-request — per-request identity
+# flows exclusively through the contextvars below).
+_state: CredentialState = CredentialState.LOCAL
+
+# Per-request namespace subject (HTTP multi-user mode).
+#
+# Bound by the hull auth middleware's resolved identity: tool handlers call
+# :func:`get_current_sub`, which prefers an explicit :func:`set_current_sub`
+# binding and otherwise falls back to hull-core's ``current_user()``
+# contextvar when the request authenticated in ``multi`` mode. ``None`` in
+# stdio mode, the CLI, and single-namespace HTTP modes (no-auth/token) —
+# those share the repo-local graph.db.
+_current_sub: contextvars.ContextVar[str | None] = contextvars.ContextVar(
+    "crg_current_sub", default=None
+)
+
+
+def get_state() -> CredentialState:
+    """Return current credential state."""
+    return _state
+
+
+def resolve_credential_state() -> CredentialState:
+    """Resolve whether any per-task model cell is configured (has a key).
+
+    Host-only check against the instance ``config.toml`` cells + key env
+    vars. Local ONNX embedding and everything except cloud summarize/embed
+    work regardless, so ``LOCAL`` is a valid steady state, not an error.
+    Takes <10ms; called during HTTP lifespan startup and by ``config``.
+    """
+    global _state
+
+    from .config import resolve_cells
+
+    cells = resolve_cells()
+    configured = any(cell.configured for cell in cells.values())
+    _state = CredentialState.CONFIGURED if configured else CredentialState.LOCAL
+    logger.info("Credential state resolved: %s", _state.value)
+    return _state
+
+
+def set_state(state: CredentialState) -> None:
+    """For testing and the config tool status action."""
+    global _state
+    _state = state
+
+
+def _sub_data_dir(sub: str) -> Path:
+    """Return per-sub data directory (creates if missing).
+
+    Each authenticated namespace gets its own scope under
+    ``<CRG_DATA_DIR>/subs/<sub>/`` so graph state never leaks across users
+    sharing one deployment process.
+    """
+    # sub must be a single path component to prevent traversal.
+    if (
+        not sub
+        or sub in (".", "..")
+        or "/" in sub
+        or "\\" in sub
+        or os.path.sep in sub
+        or (os.path.altsep and os.path.altsep in sub)
+    ):
+        raise ValueError(f"Invalid subject (must be a single path component): {sub}")
+
+    base = Path(os.environ.get("CRG_DATA_DIR", str(Path.home() / ".crg")))
+    subs_base = (base / "subs").resolve()
+
+    # defense-in-depth: still verify the resolved path stays within subs_base
+    d = (subs_base / sub).resolve()
+    if not d.is_relative_to(subs_base) or d == subs_base:
+        raise ValueError(f"Invalid subject: {sub}")
+
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def db_path_for_sub(sub: str) -> Path:
+    """Return per-sub graph.db path for multi-user mode."""
+    return _sub_data_dir(sub) / "graph.db"
+
+
+def set_current_sub(sub: str | None) -> None:
+    """Bind the namespace subject for the current request (multi-user mode).
+
+    Normally the hull auth middleware's identity is consumed implicitly via
+    :func:`get_current_sub`; this explicit binding exists for tests and
+    host tooling that must scope work to one namespace outside a request.
+    Pass ``None`` to clear.
+    """
+    _current_sub.set(sub)
+
+
+def get_current_sub() -> str | None:
+    """Return the namespace subject for the current request, or ``None``.
+
+    Resolution order:
+
+    1. Explicit :func:`set_current_sub` binding.
+    2. hull-core's request identity (``current_user()``) when the request
+       authenticated in ``multi`` mode — its namespace is the data root.
+       Worker-thread tool handlers inherit the contextvar via anyio's
+       context copy, same channel hull's own tools use.
+
+    ``None`` means shared-namespace context (stdio, CLI, no-auth/token HTTP):
+    callers use the repo-local ``graph.db``.
+    """
+    sub = _current_sub.get()
+    if sub is not None:
+        return sub
+
+    from hull_core.auth.context import current_user
+
+    try:
+        ctx = current_user()
+    except Exception:  # pragma: no cover - hull always present post de-host
+        return None
+    if ctx.mode == "multi" and ctx.namespace:
+        sub = ctx.namespace
+        # Reuse the path-safety validation so a hostile users.toml namespace
+        # cannot escape the subs/ root.
+        _sub_data_dir(sub)
+        return sub
+    return None