witan-code 0.16.0__tar.gz → 0.18.0__tar.gz

{witan_code-0.16.0 → witan_code-0.18.0}/CHANGELOG.md

@@ -6,7 +6,53 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/) (pre-1.0:
 a MINOR bump may include breaking changes).
 
-## [Unreleased]
+## [0.18.0] - 2026-09-02
+
+### Added
+
+- **`witan --target <name> code index` reaches this package.** witan-council's
+  launcher gained an app-level `--target`, and `witan code …` mounts this
+  package's cyclopts App but *not* its meta launcher, so the value is forwarded
+  into `witan_code.selected_target` and read by `_srv()`. Before this the flag
+  was bound but never routed: `cli._srv()` called `load_remote_config()` with no
+  argument, so `witan --target ci code repos` answered from the ambient target
+  while appearing to work. Standalone `witan-code --target <name> …` works too.
+
+- **`witan code index` prints the store it wrote to, unconditionally.** The one
+  command whose entire output is about where symbols went was silent about which
+  graph received them — and memory and code graphs are routed by separate
+  settings, so a target whose memory is deployed can still index onto the
+  laptop. Printed for local and shared alike: a line that appears only in the
+  bad case is one nobody has learned to look for. Carried on `IndexStats` rather
+  than recomputed by the printer, so a *failed* run reports the same
+  destination — the run where "which graph was this?" is actually open.
+
+### Fixed
+
+- **`witan-code doctor` could not say which graph was broken under
+  `code_transport = "mcp"`.** The identifying column took `os.path.basename` of
+  the store address, which is right for a local path and wrong for an
+  MCP-routed one — those end in the endpoint URL, so all of production's
+  per-repo cluster graphs rendered as the identical string `mcp)`. `StoreRef`
+  gained a `label` that answers "which graph is this row" for all three address
+  forms, and `code_store_health` returns it alongside the full `store`.
+
+- **A failed index did not always name its destination.** `IndexStats` was built
+  *after* `ensure_branch()` and the existing-hash read, both of which are remote
+  calls, so an unreachable endpoint or a rejected token raised before the stats
+  existed and the summary had nothing to print. Stats are now built straight
+  after the store resolves, and those two setup calls are wrapped so a failure
+  arrives as `IndexFailed` carrying the destination. `check_writable` is
+  deliberately left outside: it raises `SharedGraphWriteRefused`, a clean
+  self-explanatory refusal that callers assert on by type, not the unattributed
+  failure the phases exist to annotate.
+
+- **`code_transport` is parsed off a target block.** A target registered with
+  `--remote-url` now carries `code_transport = "mcp"`, so branches indexed from
+  a checkout land on the cluster where another session — and another developer —
+  can see them, instead of in a directory on one laptop.
+
+## [0.17.0] - 2026-09-01
 
 ### Fixed
 
@@ -55,6 +101,16 @@ a MINOR bump may include breaking changes).
 
 ### Changed
 
+- **Floor raised to `fastmcp>=4,<5`; the optional `tasks` extra moves to
+  `fastmcp-tasks>=4,<5`.** FastMCP 4.0 went GA, so the `fastmcp>=3.4.2,<5`
+  straddle is dropped, along with the `witan-code[tasks]`-only reason that
+  extra used to also need `--prerelease=allow` under uv. No behavior change on
+  this package's own code — witan-core's version-sniffing shims are what
+  actually moved (see its changelog); this is a dependency-floor release,
+  breaking only for a caller still resolving fastmcp 3.4.x, which pre-1.0
+  semver treats as a MINOR bump. Closes
+  `tk-move-the-fastmcp-floor-to-4-when-4-0-goes-ga-454f78`.
+
 - **`graph.check_writable` requires `actor`; `None` now means "no identity",
   full stop.** It used to fall back to `identity.actor_id()`, which gave the
   parameter two meanings depending on the caller. Every call site

{witan_code-0.16.0 → witan_code-0.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: witan-code
-Version: 0.16.0
+Version: 0.18.0
 Summary: witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)
 Project-URL: Homepage, https://github.com/mitodl/agent-kit/tree/main/mcp/servers/witan-code
 Project-URL: Repository, https://github.com/mitodl/agent-kit
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
 Requires-Dist: agent-config-kit<1,>=0.4
 Requires-Dist: cyclopts<5,>=4
-Requires-Dist: fastmcp<5,>=3.4.2
+Requires-Dist: fastmcp<5,>=4
 Requires-Dist: joserfc<2,>=1.0
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: pyyaml<7,>=6
@@ -28,7 +28,7 @@ Requires-Dist: tree-sitter-yaml<0.8,>=0.7
 Requires-Dist: tree-sitter<0.26,>=0.25
 Requires-Dist: witan-core[cli,observability,remote,sentry]<1,>=0.32
 Provides-Extra: tasks
-Requires-Dist: fastmcp-tasks<5,>=4.0.0b1; extra == 'tasks'
+Requires-Dist: fastmcp-tasks<5,>=4; extra == 'tasks'
 Description-Content-Type: text/markdown
 
 # witan-code

{witan_code-0.16.0 → witan_code-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "witan-code"
-version = "0.16.0"
+version = "0.18.0"
 description = "witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -122,7 +122,7 @@ dependencies = [
     # conflict, since both sides named the same number. Re-check it by hand on
     # every rebase; a floor one release low here is silent.
     "witan-core[cli,remote,observability,sentry]>=0.32,<1",
-    "fastmcp>=3.4.2,<5",
+    "fastmcp>=4,<5",
     "cyclopts>=4,<5",
     # [targets.<name>] override models (config.py) — also transitively pulled
     # in by fastmcp, declared explicitly since config.py imports it directly.
@@ -162,10 +162,9 @@ dependencies = [
 [project.optional-dependencies]
 # The io.modelcontextprotocol/tasks extension (SEP-2663), which lets a client
 # poll a long `code_reindex` instead of holding the tool call open. Optional
-# because it exists only for fastmcp 4.x while the pin above still spans 3.4.x,
-# and because it pulls a Docket/Redis stack that the default in-process
+# because it pulls a Docket/Redis stack that the default in-process
 # `memory://` backend does not need. server.py registers it when importable.
-tasks = ["fastmcp-tasks>=4.0.0b1,<5"]
+tasks = ["fastmcp-tasks>=4,<5"]
 
 [project.urls]
 Homepage = "https://github.com/mitodl/agent-kit/tree/main/mcp/servers/witan-code"
@@ -195,7 +194,7 @@ witan-core = { workspace = true }
 # cryptography: test_github_app generates a throwaway RSA key so the JWT path
 # is exercised for real rather than mocked. joserfc requires it at runtime, so
 # this only makes an existing import explicit.
-test = ["pytest>=8", "fastmcp-tasks>=4.0.0b1,<5", "cryptography"]
+test = ["pytest>=8", "fastmcp-tasks>=4,<5", "cryptography"]
 
 [tool.pytest.ini_options]
 pythonpath = ["."]
@@ -205,7 +204,7 @@ testpaths = ["tests"]
 packages = ["witan_code"]
 
 [tool.bumpversion]
-current_version = "0.16.0"
+current_version = "0.18.0"
 allow_dirty = true
 
 [[tool.bumpversion.files]]

witan_code-0.18.0/tests/test_cli_selected_target.py

@@ -0,0 +1,86 @@
+"""``witan code …`` dispatches to the target witan's launcher bound.
+
+This package's App is mounted by witan's CLI but its meta launcher is not, so
+witan's launcher forwards the ``--target`` it bound into
+:mod:`witan_code.selected_target` (the same forwarding ``--output-format``
+already gets, for the same reason). What is asserted here is the other end of
+that wire: that the dispatch path actually consults it.
+
+Resolving the ambient target here instead is not a cosmetic gap. ``witan code
+index`` WRITES a code graph, so it would have written to whichever deployment
+the checkout happened to match while the flag on the command line said
+otherwise — and said nothing about it.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from witan_code import cli as code_cli
+from witan_code import config as code_cfg
+from witan_code.selected_target import selected_target, set_selected_target
+
+
+@pytest.fixture(autouse=True)
+def _clean_selection():
+    """Module-level state, so a leaked value would silently steer a later test."""
+    set_selected_target(None)
+    yield
+    set_selected_target(None)
+
+
+def test_dispatch_reads_the_forwarded_target(monkeypatch):
+    seen = {}
+
+    def _record(target=None):
+        seen["target"] = target
+        return None  # in-process branch; a stub RemoteConfig is not the point
+
+    monkeypatch.setattr(code_cli, "_server", None)
+    monkeypatch.setattr(code_cfg, "load_remote_config", _record)
+    set_selected_target("qa")
+
+    code_cli._srv()
+
+    assert seen["target"] == "qa"
+
+
+def test_no_forwarded_target_leaves_resolution_where_it_was(monkeypatch):
+    """``None`` is not "no target": the standalone ``witan-code`` launcher
+    declares no ``--target``, and resolution falls through to ``WITAN_TARGET``
+    and the checkout's ``match_*`` rules exactly as it always did."""
+    seen = {}
+
+    def _record(target=None):
+        seen["target"] = target
+        return None
+
+    monkeypatch.setattr(code_cli, "_server", None)
+    monkeypatch.setattr(code_cfg, "load_remote_config", _record)
+
+    code_cli._srv()
+
+    assert seen["target"] is None
+
+
+def test_the_auth_path_reads_it_too(monkeypatch):
+    """``witan code login`` has to reach the same deployment the read commands
+    do, or it mints a token against one target and spends it on another."""
+    seen = {}
+
+    def _record(target=None):
+        seen["target"] = target
+        return None
+
+    monkeypatch.setattr(code_cfg, "load_remote_config", _record)
+    set_selected_target("ci")
+
+    with pytest.raises(SystemExit):
+        code_cli._remote_or_exit()  # no remote configured -> clean exit
+
+    assert seen["target"] == "ci"
+
+
+def test_accessor_round_trips():
+    set_selected_target("production")
+    assert selected_target() == "production"

{witan_code-0.16.0 → witan_code-0.18.0}/tests/test_config_targets.py

@@ -377,3 +377,78 @@ def test_unknown_index_role_is_rejected(monkeypatch, toml_file):
 
     with pytest.raises(ValueError, match="Unknown index_role"):
         load()
+
+
+# ── The seam with `witan target add` ─────────────────────────────────────────
+
+
+def test_the_block_witan_target_add_writes_routes_code_graphs_to_the_cluster(
+    monkeypatch, toml_file
+):
+    """The exact block `witan target add --remote-url …` emits, read back here.
+
+    These are two packages agreeing by convention, not by a shared type: witan
+    (witan-council) renders the TOML, witan-code parses it, and nothing fails
+    loudly if they drift. Before `target add` learned `--code-transport`, a
+    deployed target had no `code_transport` key at all and fell through to the
+    `direct` default, leaving code graphs on the developer's own machine while
+    memory went to the deployment — silently, since a local store is a working
+    store. Keep this literal in step with `witan.cli.targets._FIELD_ORDER`.
+    """
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.ol]
+            remote_url = "https://witan.ci.ol.mit.edu/mcp"
+            oidc_issuer = "https://sso-ci.ol.mit.edu/realms/ol-platform-engineering"
+            oidc_audience = "witan"
+            code_transport = "mcp"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_TRANSPORT", raising=False)
+    monkeypatch.delenv("WITAN_CODE_SERVER", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "ol"
+    assert cfg.code_transport == "mcp"
+    # `mcp` alone makes it a cluster graph — code_server stays unset, because
+    # the deployment holds the address and resolves the actor from the JWT.
+    assert cfg.code_server is None
+    assert cfg.is_cluster
+
+
+def test_a_deployed_target_without_code_transport_still_falls_back_to_local(
+    monkeypatch, toml_file
+):
+    """The pre-fix shape, pinned so the regression is legible rather than silent.
+
+    This is what every target registered before 2026-09-01 looks like. It is
+    not an error and never was — which is the whole problem, and why the
+    onboarding doc now tells people to re-run `target add --force`.
+    """
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.ol]
+            remote_url = "https://witan.ci.ol.mit.edu/mcp"
+            oidc_issuer = "https://sso-ci.ol.mit.edu/realms/ol-platform-engineering"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_TRANSPORT", raising=False)
+    monkeypatch.delenv("WITAN_CODE_SERVER", raising=False)
+
+    cfg = load()
+    assert cfg.code_transport == "direct"
+    assert not cfg.is_cluster
+    # Memory is deployed while code graphs are not — the split this task fixed.
+    assert load_remote_config() is not None

{witan_code-0.16.0 → witan_code-0.18.0}/tests/test_github_app.py

@@ -20,6 +20,7 @@ from witan_code.github_app import (
     EXIT_ERROR,
     EXIT_NOT_CONFIGURED,
     EXIT_OK,
+    GH_TOKEN_ENV_VAR,
     GITHUB_API_URL,
     INSTALLATION_ID_ENV_VAR,
     KEY_FILE_ENV_VAR,
@@ -27,8 +28,11 @@ from witan_code.github_app import (
     GitHubAppError,
     app_jwt,
     from_env,
+    api_repo_host,
     installation_token,
     main,
+    repo_is_private,
+    repo_owner_name,
 )
 
 _JWT_MAX_LIFETIME = 600  # GitHub's hard limit on an App JWT.
@@ -308,3 +312,218 @@ def test_main_reports_a_mint_failure(tmp_path, pem, monkeypatch, capsys):
 
 def test_main_rejects_an_unknown_argument():
     assert main(["--nope"]) == EXIT_ERROR
+
+
+# ── repo_owner_name / repo_is_private ─────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    ("uri", "expected"),
+    [
+        ("https://github.com/mitodl/agent-kit", ("mitodl", "agent-kit")),
+        ("https://github.com/mitodl/agent-kit/", ("mitodl", "agent-kit")),
+        ("https://github.com/mitodl/agent-kit.git", ("mitodl", "agent-kit")),
+    ],
+)
+def test_repo_owner_name_splits_a_canonical_uri(uri, expected):
+    assert repo_owner_name(uri) == expected
+
+
+@pytest.mark.parametrize(
+    "uri",
+    [
+        "agent-kit",
+        "",
+        "https://github.com/",
+        "https://github.com/mitodl",
+        # Scheme-relative: `urlsplit` gives it a netloc and no scheme, so a
+        # scheme check that only looked for "not empty" would let it through.
+        "//github.com/mitodl/agent-kit",
+        "http://github.com/mitodl/agent-kit",
+        "git@github.com:mitodl/agent-kit.git",
+    ],
+)
+def test_repo_owner_name_rejects_something_that_is_not_a_repo_uri(uri):
+    with pytest.raises(GitHubAppError, match="owner and repository name"):
+        repo_owner_name(uri)
+
+
+def test_repo_owner_name_rejects_extra_path_components():
+    """`.../a/b/c/d` must not be cleared by `c/d`'s visibility."""
+    with pytest.raises(GitHubAppError, match="owner and repository name"):
+        repo_owner_name("https://github.com/mitodl/agent-kit/tree/main")
+
+
+def test_repo_owner_name_rejects_a_host_the_api_does_not_answer_for():
+    """The clone uses the whole URI; the check uses only owner/name.
+
+    Left unchecked, `https://other.example/mitodl/agent-kit` would be approved
+    on `github.com/mitodl/agent-kit`'s visibility and then cloned from
+    `other.example` — the guard satisfied by a different repository entirely.
+    """
+    with pytest.raises(GitHubAppError, match="answers for 'github.com'"):
+        repo_owner_name("https://other.example/mitodl/agent-kit")
+
+
+def test_repo_owner_name_follows_an_enterprise_api_host():
+    api = "https://ghe.example/api/v3"
+    assert repo_owner_name("https://ghe.example/mitodl/agent-kit", api_url=api) == (
+        "mitodl",
+        "agent-kit",
+    )
+    # And github.com is then the mismatched host, not the privileged one.
+    with pytest.raises(GitHubAppError, match="answers for 'ghe.example'"):
+        repo_owner_name("https://github.com/mitodl/agent-kit", api_url=api)
+
+
+@pytest.mark.parametrize(
+    ("api_url", "expected"),
+    [
+        ("https://api.github.com", "github.com"),
+        ("https://ghe.example/api/v3", "ghe.example"),
+        ("https://API.GITHUB.COM/", "github.com"),
+    ],
+)
+def test_api_repo_host(api_url, expected):
+    assert api_repo_host(api_url) == expected
+
+
+def test_repo_is_private_asks_github_as_the_installation():
+    seen = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        seen["url"] = str(request.url)
+        seen["auth"] = request.headers["Authorization"]
+        seen["method"] = request.method
+        return httpx2.Response(200, json={"private": True})
+
+    private = repo_is_private(
+        "https://github.com/mitodl/secret-thing", "ghs_x", client=_client(handler)
+    )
+
+    assert private is True
+    assert seen["method"] == "GET"
+    assert seen["url"] == "https://api.github.com/repos/mitodl/secret-thing"
+    # The installation token, not the App JWT: the App itself cannot see repos.
+    assert seen["auth"] == "Bearer ghs_x"
+
+
+def test_repo_is_private_is_false_for_a_public_repo():
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json={"private": False})
+
+    assert (
+        repo_is_private(
+            "https://github.com/mitodl/agent-kit", "ghs_x", client=_client(handler)
+        )
+        is False
+    )
+
+
+def test_repo_is_private_raises_on_a_404_rather_than_calling_it_public():
+    """An installation that cannot see a repo has not answered the question."""
+
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(404, json={"message": "Not Found"})
+
+    with pytest.raises(GitHubAppError, match="would not describe"):
+        repo_is_private(
+            "https://github.com/mitodl/gone", "ghs_x", client=_client(handler)
+        )
+
+
+@pytest.mark.parametrize("body", [{}, {"private": "yes"}])
+def test_repo_is_private_raises_when_the_answer_is_not_a_boolean(body):
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json=body)
+
+    with pytest.raises(GitHubAppError):
+        repo_is_private(
+            "https://github.com/mitodl/agent-kit", "ghs_x", client=_client(handler)
+        )
+
+
+def test_repo_is_private_raises_when_github_is_unreachable():
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        raise httpx2.ConnectError("no route")
+
+    with pytest.raises(GitHubAppError, match="Could not reach"):
+        repo_is_private(
+            "https://github.com/mitodl/agent-kit", "ghs_x", client=_client(handler)
+        )
+
+
+def test_repo_is_private_leaves_a_caller_supplied_client_open():
+    client = _client(lambda _: httpx2.Response(200, json={"private": False}))
+    repo_is_private("https://github.com/mitodl/agent-kit", "ghs_x", client=client)
+    assert not client.is_closed
+
+
+# ── main --visibility ─────────────────────────────────────────────────────────
+
+
+def test_main_visibility_prints_the_answer(tmp_path, pem, monkeypatch, capsys):
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv(GH_TOKEN_ENV_VAR, "ghs_already_minted")
+    seen = {}
+
+    def fake(repo, token, *, api_url):
+        seen.update(repo=repo, token=token, api_url=api_url)
+        return True
+
+    monkeypatch.setattr("witan_code.github_app.repo_is_private", fake)
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_OK
+    assert capsys.readouterr().out.strip() == "private"
+    # Reuses the token the entrypoint already minted rather than exchanging a
+    # second App JWT for another one — see GH_TOKEN_ENV_VAR.
+    assert seen["token"] == "ghs_already_minted"
+    assert seen["repo"] == "https://github.com/mitodl/x"
+
+
+def test_main_visibility_mints_a_token_when_none_is_in_the_environment(
+    tmp_path, pem, monkeypatch, capsys
+):
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.delenv(GH_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(
+        "witan_code.github_app.installation_token",
+        lambda _creds, *, api_url: "ghs_fresh",
+    )
+    monkeypatch.setattr(
+        "witan_code.github_app.repo_is_private",
+        lambda _repo, token, *, api_url: token == "ghs_fresh",
+    )
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_OK
+    assert capsys.readouterr().out.strip() == "private"
+
+
+def test_main_visibility_reports_not_configured_without_an_app(monkeypatch):
+    """No App means no private repo could have been cloned in the first place."""
+    for name in (APP_ID_ENV_VAR, INSTALLATION_ID_ENV_VAR, KEY_FILE_ENV_VAR):
+        monkeypatch.delenv(name, raising=False)
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_NOT_CONFIGURED
+
+
+def test_main_visibility_reports_a_lookup_failure(tmp_path, pem, monkeypatch, capsys):
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv(GH_TOKEN_ENV_VAR, "ghs_x")
+
+    def boom(_repo, _token, *, api_url):
+        raise GitHubAppError("GitHub said no")
+
+    monkeypatch.setattr("witan_code.github_app.repo_is_private", boom)
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_ERROR
+    assert "GitHub said no" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("argv", [["--visibility"], ["--visibility", "a", "b"]])
+def test_main_rejects_a_malformed_visibility_invocation(
+    argv, tmp_path, pem, monkeypatch
+):
+    """The usage error comes before any credential or network work."""
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    assert main(argv) == EXIT_ERROR

witan_code-0.18.0/tests/test_index_reports_its_store.py

@@ -0,0 +1,122 @@
+"""`witan code index` has to say which graph it wrote.
+
+Memory and code graphs are routed by SEPARATE settings, so a target whose
+memory is deployed can still index onto the laptop — three non-maintainers were
+in exactly that state on production. The one command whose entire output is
+about where symbols went was silent about which store received them.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from witan_code import cli as cli_module
+from witan_code import indexer
+
+
+def test_a_successful_index_names_the_store(monkeypatch, capsys):
+    stats = indexer.IndexStats(
+        scanned=12,
+        indexed=12,
+        symbols=88,
+        store="/home/dev/.local/share/witan-code/x.omni",
+    )
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "/home/dev/.local/share/witan-code/x.omni" in capsys.readouterr().out
+
+
+def test_a_shared_store_is_reported_the_same_way(monkeypatch, capsys):
+    """Printed for local and shared alike. A line that appears only in the bad
+    case is a line nobody has learned to look for — and reading it is how "where
+    did this go" gets answered without knowing the setting exists."""
+    stats = indexer.IndexStats(
+        scanned=12, store="github.com/mitodl/agent-kit (via https://witan.example/mcp)"
+    )
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "https://witan.example/mcp" in capsys.readouterr().out
+
+
+def test_the_branch_view_is_named_when_there_is_one(monkeypatch, capsys):
+    """On a shared graph the view is per writer per git branch, so the store
+    alone does not identify what a reader has to look at."""
+    stats = indexer.IndexStats(store="s", branch="act-0eb-feature-x")
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "branch=act-0eb-feature-x" in capsys.readouterr().out
+
+
+def test_the_default_branch_prints_no_branch_field(monkeypatch, capsys):
+    stats = indexer.IndexStats(store="s")
+    monkeypatch.setattr(indexer, "index_path", lambda path, *, force=False, **k: stats)
+
+    cli_module.index(Path("."))
+
+    assert "branch=" not in capsys.readouterr().out
+
+
+def test_a_failed_index_still_names_the_store(monkeypatch, capsys):
+    """The failing run is the one where "which graph was this?" is the open
+    question, so the destination is carried on the stats rather than recomputed
+    by the printer."""
+    stats = indexer.IndexStats(scanned=657, store="https://witan.example/mcp")
+
+    def failing_index(path, *, force=False, **kwargs):
+        raise indexer.IndexFailed(
+            "load of nodes and edges",
+            RuntimeError("timed out"),
+            stats=stats,
+            elapsed=181.0,
+            detail={"records": 9000},
+        )
+
+    monkeypatch.setattr(indexer, "index_path", failing_index)
+
+    with pytest.raises(indexer.IndexFailed):
+        cli_module.index(Path("."))
+
+    assert "https://witan.example/mcp" in capsys.readouterr().out
+
+
+def test_a_setup_failure_names_the_store_it_was_reaching(tmp_path, monkeypatch):
+    """Regression, PR #316 review: the guarantee has to cover setup, not just
+    the load.
+
+    `ensure_branch` and the existing-hash read are REMOTE calls, and `IndexStats`
+    used to be built after both. So an unreachable endpoint or a rejected token
+    raised before the stats object existed, `_index` had nothing to print, and
+    the run that most needed a destination reported none — the exact gap the
+    "a failed run still identifies its graph" guarantee was added to close.
+    """
+    import subprocess
+
+    from witan_code import config as cfg_module
+    from witan_code.graph import OmnigraphClient
+
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/test/cg")
+    monkeypatch.setenv("WITAN_CODE_DIR", str(tmp_path / "code"))
+    src = tmp_path / "repo"
+    src.mkdir()
+    subprocess.run(["git", "init", "-q", "-b", "main"], cwd=src, check=True)
+    (src / "a.py").write_text("def a():\n    return 1\n")
+
+    def _unreachable(self, *a, **k):
+        raise RuntimeError("connection refused")
+
+    monkeypatch.setattr(OmnigraphClient, "ensure_branch", _unreachable)
+
+    with pytest.raises(indexer.IndexFailed) as excinfo:
+        indexer.index_path(src, config=cfg_module.load())
+
+    assert excinfo.value.phase == "branch setup"
+    assert excinfo.value.stats.store  # the destination, not an empty string
+    assert "cg" in excinfo.value.stats.store

{witan_code-0.16.0 → witan_code-0.18.0}/tests/test_indexer.py

@@ -21,6 +21,9 @@ def test_index_extracts_symbols_and_edges(sample_repo):
 
     slug = repo_mod.detect()
     store = store_mod.store_for_repo(slug, cfg)
+    # The destination the summary reports comes off the run itself, so this is
+    # what stops that line drifting from where the rows actually landed.
+    assert stats.store == str(store)
     client = OmnigraphClient(str(store), cfg.queries_dir)
 
     runs = client.read("code_read.gq", "find_by_name", {"name": "run"})