witan-code 0.4.0__tar.gz → 0.6.0__tar.gz

{witan_code-0.4.0 → witan_code-0.6.0}/CHANGELOG.md

@@ -6,6 +6,43 @@ 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).
 
+## [0.6.0] - 2026-07-21
+
+### Fixed
+
+- **`repo.detect(override=...)` and the `WITAN_REPO` env var now route
+  through `normalise`** (issue #142), same as an auto-detected git remote —
+  matching the fix in witan-council 0.6.0. Previously an explicitly-passed
+  `repo=` (or `WITAN_REPO`) was stored verbatim, bypassing
+  canonicalization. `graph_id` (the shared-cluster graph id) already
+  case-folded unconditionally and needs no change; a repo whose canonical
+  key changes case after this fix should be re-indexed (`witan-code
+  reindex`) so its per-repo store lands under the new key.
+- Depends on `witan-core[cli]>=0.2,<1` (unchanged range; picks up 0.4.0's
+  repo-key case-fold in `normalise`, which this package's `repo.detect`
+  relies on).
+
+## [0.5.0] - 2026-07-20
+
+### Added
+
+- `config.toml` + `[targets.<name>]` support (previously env-var only):
+  `WITAN_CONFIG` / `~/.config/witan/config.toml`, a global `code_dir`/
+  `author`, and named targets overriding `code_dir`/`author`, selected by
+  `WITAN_TARGET` env var, an explicit `load(target=...)`, or auto-detection
+  via `match_paths`/`match_repos`/`match_hosts`/`match_orgs` (same
+  precedence and file as witan — see `witan_core.target_config` and
+  `witan.config.load()`'s docstring). A target can carry witan's
+  `server`/`graph`/`token` alongside this server's `code_dir` under one
+  name; witan-code reads only the fields it knows. `Config` gained
+  `target_name`. `load()` now optionally takes a `target` argument (was
+  zero-argument only). New dependency: `pydantic>=2,<3`.
+
+### Changed
+
+- Now depends on `witan-core[cli]>=0.2,<1` (unchanged range; picks up
+  0.3.0, which adds the shared target-routing logic this release uses).
+
 ## [0.4.0] - 2026-07-16
 
 ### Added

{witan_code-0.4.0 → witan_code-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: witan-code
-Version: 0.4.0
+Version: 0.6.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
@@ -13,6 +13,7 @@ Requires-Python: >=3.11
 Requires-Dist: agent-config-kit<1,>=0.4
 Requires-Dist: cyclopts<5,>=4
 Requires-Dist: fastmcp<4,>=3.4.2
+Requires-Dist: pydantic<3,>=2
 Requires-Dist: pyyaml<7,>=6
 Requires-Dist: rich>=13
 Requires-Dist: tomli-w<2,>=1
@@ -334,12 +335,35 @@ symlink alternative:
 | `WITAN_AUTHOR` / `USER` | `unknown` | attribution string |
 | `WITAN_REPO` | — | override the detected repo slug |
 | `WITAN_CODE_OPTIMIZE_INTERVAL` | `86400` (daily) | throttle window (seconds) for `checkpoint`'s opportunistic store compaction; `0` disables it |
+| `WITAN_CONFIG` | `~/.config/witan/config.toml` | config file path (see below) |
+| `WITAN_TARGET` | — | force a named `[targets.<name>]` block instead of auto-detecting one |
 
 The store URI for a repo is `<dir>/<sanitized-slug>.omni`, where the slug's `/`
 and `:` are replaced with `_`. The shared cross-repo bridge lives alongside them
 at `<dir>/_bridge.omni` and is created lazily on the first index that yields any
 bindings.
 
+### config.toml
+
+witan-code reads the same `config.toml` as witan (witan-council) — a global
+`code_dir`/`author`, plus named `[targets.<name>]` blocks that override them
+and are selected by `WITAN_TARGET`, `load(target=...)` (Python API only — no
+CLI `--target` flag yet), or auto-detection against the current
+repo/checkout (`match_paths` > `match_repos` > `match_hosts` > `match_orgs`
+— see witan's README/`witan/config.py` docstring for the full precedence).
+Because the file is shared, one target block can carry witan's
+`server`/`graph`/`token` alongside `code_dir` under
+the same name — each server reads only the fields it knows:
+
+```toml
+[targets.work]
+server = "http://witan.internal:8080"  # witan (witan-council)
+code_dir = "/mnt/work/witan-code"      # witan-code
+match_orgs = ["myorg"]
+```
+
+Environment variables always win over `config.toml`.
+
 ## MCP tools
 
 Each tool resolves the per-repo store from the current working directory and

{witan_code-0.4.0 → witan_code-0.6.0}/README.md

@@ -305,12 +305,35 @@ symlink alternative:
 | `WITAN_AUTHOR` / `USER` | `unknown` | attribution string |
 | `WITAN_REPO` | — | override the detected repo slug |
 | `WITAN_CODE_OPTIMIZE_INTERVAL` | `86400` (daily) | throttle window (seconds) for `checkpoint`'s opportunistic store compaction; `0` disables it |
+| `WITAN_CONFIG` | `~/.config/witan/config.toml` | config file path (see below) |
+| `WITAN_TARGET` | — | force a named `[targets.<name>]` block instead of auto-detecting one |
 
 The store URI for a repo is `<dir>/<sanitized-slug>.omni`, where the slug's `/`
 and `:` are replaced with `_`. The shared cross-repo bridge lives alongside them
 at `<dir>/_bridge.omni` and is created lazily on the first index that yields any
 bindings.
 
+### config.toml
+
+witan-code reads the same `config.toml` as witan (witan-council) — a global
+`code_dir`/`author`, plus named `[targets.<name>]` blocks that override them
+and are selected by `WITAN_TARGET`, `load(target=...)` (Python API only — no
+CLI `--target` flag yet), or auto-detection against the current
+repo/checkout (`match_paths` > `match_repos` > `match_hosts` > `match_orgs`
+— see witan's README/`witan/config.py` docstring for the full precedence).
+Because the file is shared, one target block can carry witan's
+`server`/`graph`/`token` alongside `code_dir` under
+the same name — each server reads only the fields it knows:
+
+```toml
+[targets.work]
+server = "http://witan.internal:8080"  # witan (witan-council)
+code_dir = "/mnt/work/witan-code"      # witan-code
+match_orgs = ["myorg"]
+```
+
+Environment variables always win over `config.toml`.
+
 ## MCP tools
 
 Each tool resolves the per-repo store from the current working directory and

{witan_code-0.4.0 → witan_code-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "witan-code"
-version = "0.4.0"
+version = "0.6.0"
 description = "witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -14,6 +14,9 @@ dependencies = [
     "witan-core[cli]>=0.2,<1",
     "fastmcp>=3.4.2,<4",
     "cyclopts>=4,<5",
+    # [targets.<name>] override models (config.py) — also transitively pulled
+    # in by fastmcp, declared explicitly since config.py imports it directly.
+    "pydantic>=2,<3",
     # Pinned to 0.25.x: tree-sitter 0.26.0 has a use-after-free in its pyo3 Node
     # binding that segfaults (exit 139) under the heavy .parent()/.children()
     # churn _walk_defs does on real-world-sized files — deterministically on the
@@ -58,8 +61,8 @@ build-backend = "hatchling.build"
 # agent-config-kit version bumped alongside it — even before that version
 # has actually landed on PyPI. Published wheels only see the PyPI-range
 # dependency declared above.
-agent-config-kit = { path = "../../../packages/agent-config-kit", editable = true }
-witan-core = { path = "../../../packages/witan-core", editable = true }
+agent-config-kit = { workspace = true }
+witan-core = { workspace = true }
 
 [dependency-groups]
 test = ["pytest>=8"]
@@ -72,7 +75,7 @@ testpaths = ["tests"]
 packages = ["witan_code"]
 
 [tool.bumpversion]
-current_version = "0.4.0"
+current_version = "0.6.0"
 allow_dirty = true
 
 [[tool.bumpversion.files]]

witan_code-0.6.0/tests/test_config.py

@@ -0,0 +1,64 @@
+"""Canonical cluster graph-id derivation (config.graph_id).
+
+This id is a cross-repo contract: witan-code addresses `--graph <id>` and
+ol-infrastructure's cluster.yaml provisioning declares the same `<id>`. If this
+algorithm drifts from the provisioning side, clients address graphs the cluster
+never created — so pin the observable mapping here.
+"""
+
+from witan_code import config
+
+
+def test_graph_id_canonical_example():
+    # The example from the deployment decision; must be byte-for-byte stable.
+    assert (
+        config.graph_id("https://github.com/mitodl/ol-django")
+        == "code-github-com-mitodl-ol-django"
+    )
+
+
+def test_graph_id_matches_constraint():
+    for repo in (
+        "https://github.com/mitodl/ol-django",
+        "http://example.com/x",
+        "git@github.com:mitodl/agent-kit.git",
+        "github.com/mitodl/ol-infrastructure",
+        "https://github.com/MITODL/Mixed_Case.Repo",
+    ):
+        assert config.GRAPH_ID_RE.match(config.graph_id(repo)), repo
+
+
+def test_graph_id_no_underscores_and_lowercase():
+    gid = config.graph_id("https://github.com/MITODL/Mixed_Case.Repo")
+    assert "_" not in gid
+    assert gid == gid.lower()
+
+
+def test_graph_id_strips_scheme():
+    with_scheme = config.graph_id("https://github.com/mitodl/x")
+    without = config.graph_id("github.com/mitodl/x")
+    assert with_scheme == without == "code-github-com-mitodl-x"
+
+
+def test_graph_id_is_prefixed():
+    assert config.graph_id("github.com/a/b").startswith(config.CODE_GRAPH_PREFIX)
+
+
+def test_graph_id_long_repo_truncates_with_hash():
+    long_repo = "https://github.com/mitodl/" + "a" * 200
+    gid = config.graph_id(long_repo)
+    assert len(gid) <= 64
+    assert config.GRAPH_ID_RE.match(gid)
+    # Distinct long repos disambiguate via the URI hash, never colliding.
+    other = config.graph_id("https://github.com/mitodl/" + "a" * 199 + "b")
+    assert gid != other
+
+
+def test_graph_id_is_deterministic():
+    repo = "https://github.com/mitodl/" + "z" * 100
+    assert config.graph_id(repo) == config.graph_id(repo)
+
+
+def test_bridge_graph_id_constant():
+    assert config.BRIDGE_GRAPH_ID == "code-bridge"
+    assert config.GRAPH_ID_RE.match(config.BRIDGE_GRAPH_ID)

witan_code-0.6.0/tests/test_config_targets.py

@@ -0,0 +1,247 @@
+"""Tests for witan_code.config's [targets.<name>] routing (load(), _parse_targets).
+
+The match-precedence logic itself (match_paths/match_repos/match_hosts/
+match_orgs) lives in witan_core.target_config, with its own test suite at
+packages/witan-core/tests/test_target_config.py; this file covers only
+witan-code's own typed target model and load() integration.
+"""
+
+import textwrap
+
+import pytest
+
+from witan_code.config import _parse_targets, load
+
+
+# ── _parse_targets ────────────────────────────────────────────────────────────
+
+
+def test_parse_targets_empty():
+    assert _parse_targets({}) == []
+
+
+def test_parse_targets_basic():
+    raw = {
+        "targets": {"work": {"code_dir": "/mnt/work-code", "match_orgs": ["mitodl"]}}
+    }
+    result = _parse_targets(raw)
+    assert len(result) == 1
+    assert result[0].name == "work"
+    assert result[0].code_dir == "/mnt/work-code"
+    assert result[0].match_orgs == ["mitodl"]
+    assert result[0].match_paths == []
+
+
+def test_parse_targets_targets_not_a_table():
+    with pytest.raises(ValueError, match="must be a table"):
+        _parse_targets({"targets": ["not", "a", "table"]})
+
+
+def test_parse_targets_target_entry_not_a_table():
+    with pytest.raises(ValueError, match="must be a table"):
+        _parse_targets({"targets": {"work": "not-a-table"}})
+
+
+def test_parse_targets_invalid_match_orgs_type():
+    raw = {"targets": {"work": {"match_orgs": 42}}}
+    with pytest.raises(ValueError, match="Expected a list or string"):
+        _parse_targets(raw)
+
+
+# ── load() ────────────────────────────────────────────────────────────────────
+
+
+@pytest.fixture
+def toml_file(tmp_path):
+    """Write a config.toml and return its path."""
+
+    def _write(content: str) -> str:
+        p = tmp_path / "config.toml"
+        p.write_text(textwrap.dedent(content))
+        return str(p)
+
+    return _write
+
+
+def test_load_defaults(monkeypatch, toml_file):
+    monkeypatch.setenv("WITAN_CONFIG", toml_file(""))
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/nobody/nothing")
+
+    cfg = load()
+    assert cfg.target_name is None
+    assert str(cfg.code_dir).endswith("/.local/share/witan/code")
+
+
+def test_load_env_overrides_file(monkeypatch, toml_file):
+    monkeypatch.setenv("WITAN_CONFIG", toml_file('code_dir = "/from-file"'))
+    monkeypatch.setenv("WITAN_CODE_DIR", "/from-env")
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/nobody/nothing")
+
+    cfg = load()
+    assert str(cfg.code_dir) == "/from-env"
+
+
+def test_load_global_file_code_dir(monkeypatch, toml_file):
+    monkeypatch.setenv("WITAN_CONFIG", toml_file('code_dir = "/from-file"'))
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/nobody/nothing")
+
+    cfg = load()
+    assert str(cfg.code_dir) == "/from-file"
+
+
+def test_load_auto_detects_target_by_org(monkeypatch, toml_file):
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.work]
+            code_dir = "/work-code"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "work"
+    assert str(cfg.code_dir) == "/work-code"
+
+
+def test_load_auto_detects_target_by_path(monkeypatch, toml_file, tmp_path):
+    checkout = tmp_path / "code" / "personal" / "dotfiles"
+    checkout.mkdir(parents=True)
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            f"""
+            [targets.personal]
+            code_dir = "/personal-code"
+            match_paths = [{str(tmp_path / "code" / "personal")!r}]
+            """
+        ),
+    )
+    monkeypatch.setenv("CLAUDE_PROJECT_DIR", str(checkout))
+    monkeypatch.setenv("WITAN_REPO", "")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "personal"
+    assert str(cfg.code_dir) == "/personal-code"
+
+
+def test_load_explicit_target_arg(monkeypatch, toml_file):
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.personal]
+            code_dir = "/personal-code"
+            match_orgs = ["alice"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+
+    cfg = load(target="personal")
+    assert cfg.target_name == "personal"
+    assert str(cfg.code_dir) == "/personal-code"
+
+
+def test_load_witan_target_env(monkeypatch, toml_file):
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.work]
+            code_dir = "/work-code"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_TARGET", "work")
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "work"
+
+
+def test_load_target_inherits_global_defaults(monkeypatch, toml_file):
+    """A target that omits author falls through to the global config value."""
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            author = "Alice"
+
+            [targets.work]
+            code_dir = "/work-code"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_AUTHOR", raising=False)
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "work"
+    assert cfg.author == "Alice"
+
+
+def test_load_unknown_explicit_target_raises(monkeypatch, toml_file):
+    monkeypatch.setenv("WITAN_CONFIG", toml_file('[targets.work]\nmatch_orgs = ["x"]'))
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+
+    with pytest.raises(ValueError, match="Unknown target 'nope'"):
+        load(target="nope")
+
+
+def test_load_missing_config_file_uses_defaults(monkeypatch, tmp_path):
+    monkeypatch.setenv("WITAN_CONFIG", str(tmp_path / "nonexistent.toml"))
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/nobody/nothing")
+
+    cfg = load()
+    assert cfg.target_name is None
+
+
+def test_load_malformed_toml_raises(monkeypatch, tmp_path):
+    bad = tmp_path / "bad.toml"
+    bad.write_text("this is not [ valid toml !!!")
+    monkeypatch.setenv("WITAN_CONFIG", str(bad))
+
+    with pytest.raises(ValueError, match="Failed to parse config file"):
+        load()
+
+
+def test_load_shares_config_file_with_witan(monkeypatch, toml_file):
+    """One [targets.<name>] block can carry both witan's server/graph and
+    witan-code's code_dir — this server only reads the fields it knows."""
+    monkeypatch.setenv(
+        "WITAN_CONFIG",
+        toml_file(
+            """
+            [targets.work]
+            server = "http://work:8080"
+            graph = "council-work"
+            code_dir = "/work-code"
+            match_orgs = ["mitodl"]
+            """
+        ),
+    )
+    monkeypatch.setenv("WITAN_REPO", "https://github.com/mitodl/agent-kit")
+    monkeypatch.delenv("WITAN_TARGET", raising=False)
+    monkeypatch.delenv("WITAN_CODE_DIR", raising=False)
+
+    cfg = load()
+    assert cfg.target_name == "work"
+    assert str(cfg.code_dir) == "/work-code"

{witan_code-0.4.0 → witan_code-0.6.0}/tests/test_repo.py

@@ -18,6 +18,42 @@ def test_detect_env_override(monkeypatch):
     assert repo.detect() == "https://github.com/test/cg"
 
 
+def test_detect_env_override_is_normalised(monkeypatch):
+    monkeypatch.setenv("WITAN_REPO", "https://GitHub.com/MITODL/OL-Django")
+    assert repo.detect() == "https://github.com/mitodl/ol-django"
+
+
+@pytest.mark.skipif(shutil.which("git") is None, reason="git not on PATH")
+def test_detect_empty_env_disables_autodetection(monkeypatch, tmp_path):
+    """An explicit empty WITAN_REPO must disable auto-detection outright,
+    matching witan-council's repo.detect — not fall through to git remote
+    lookup (the walrus-operator `if env_repo := ...` form treats "" as
+    falsy and used to do exactly that)."""
+    monkeypatch.setenv("WITAN_REPO", "")
+    subprocess.run(["git", "init", "-q", str(tmp_path)], check=True)
+    subprocess.run(
+        [
+            "git",
+            "-C",
+            str(tmp_path),
+            "remote",
+            "add",
+            "origin",
+            "git@github.com:mitodl/should-not-be-detected.git",
+        ],
+        check=True,
+    )
+    assert repo.detect(start=tmp_path) is None
+
+
+def test_detect_override_arg_is_normalised(monkeypatch):
+    monkeypatch.delenv("WITAN_REPO", raising=False)
+    assert (
+        repo.detect(override="git@github.com:MITODL/OL-Django.git")
+        == "https://github.com/mitodl/ol-django"
+    )
+
+
 @pytest.mark.skipif(shutil.which("git") is None, reason="git not on PATH")
 def test_detect_tolerates_multivalued_fetch(tmp_path, monkeypatch):
     # git allows several `fetch =` lines under a remote; configparser rejects

witan_code-0.6.0/witan_code/config.py

@@ -0,0 +1,214 @@
+import hashlib
+import os
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+from witan_core.config_file import load_toml as _load_toml_shared
+from witan_core.target_config import (
+    local_project_path,
+    match_target,
+    parse_target_tables,
+    to_list,
+)
+
+from . import repo as repo_module
+
+# Bundled query files, resolved relative to this file.
+_QUERIES_DIR = Path(__file__).parent / "queries"
+_SCHEMA_FILE = Path(__file__).parent / "schema" / "code-schema.pg"
+_BRIDGE_SCHEMA_FILE = Path(__file__).parent / "schema" / "bridge-schema.pg"
+_DEFAULT_CODE_DIR = Path.home() / ".local" / "share" / "witan" / "code"
+
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "witan" / "config.toml"
+"""Shared with witan (witan-council) — see witan_core.config_file. A
+[targets.<name>] block can carry ``code_dir`` here alongside witan's
+``server``/``graph``/``token`` under the same name, routed together."""
+
+# Filename of the single shared cross-repo bridge store, a sibling of the
+# per-repo `<slug>.omni` stores in code_dir. Not routed through sanitize_slug
+# (whose .strip("_") would eat the leading underscore); no real repo slug
+# resolves to this name.
+BRIDGE_STORE_NAME = "_bridge.omni"
+
+
+@dataclass(frozen=True)
+class Config:
+    code_dir: Path
+    """Directory holding per-repo code stores (one ``<slug>.omni`` each)."""
+
+    author: str
+    """Attribution string (carried for parity with Layer 1; unused on inserts)."""
+
+    queries_dir: Path
+    """Directory containing code_read.gq, code_mutations.gq, delete.gq."""
+
+    schema_file: Path
+    """Path to code-schema.pg, used to lazily init a per-repo store."""
+
+    bridge_schema_file: Path
+    """Path to bridge-schema.pg, used to lazily init the shared bridge store."""
+
+    target_name: str | None = None
+    """Name of the matched [targets.<name>] section, or None for global defaults."""
+
+
+class _Target(BaseModel):
+    model_config = ConfigDict(frozen=True)
+
+    name: str
+    code_dir: str | None = None
+    author: str | None = None
+    match_orgs: list[str] = Field(default_factory=list)
+    match_repos: list[str] = Field(default_factory=list)
+    match_hosts: list[str] = Field(default_factory=list)
+    match_paths: list[str] = Field(default_factory=list)
+
+    @field_validator(
+        "match_orgs", "match_repos", "match_hosts", "match_paths", mode="before"
+    )
+    @classmethod
+    def _normalize_match_list(cls, v: object) -> list[str]:
+        return to_list(v)
+
+
+def _load_toml() -> dict:
+    """Load WITAN_CONFIG path or ~/.config/witan/config.toml. Returns {} on missing file.
+
+    Reads the same file as witan (witan-council) — see DEFAULT_CONFIG_PATH.
+    """
+    return _load_toml_shared(DEFAULT_CONFIG_PATH)
+
+
+def _parse_targets(raw: dict) -> list[_Target]:
+    return [_Target(name=name, **cfg) for name, cfg in parse_target_tables(raw).items()]
+
+
+def _first(*values: str | None, default: str | None = None) -> str | None:
+    for v in values:
+        if v:
+            return v
+    return default
+
+
+def load(target: str | None = None) -> Config:
+    """Load config from config.toml + environment, selecting a named target if applicable.
+
+    Resolution order (highest -> lowest precedence):
+    1. Environment variables (WITAN_CODE_DIR, WITAN_AUTHOR)
+    2. Named target: ``target`` arg > WITAN_TARGET env var > auto-detect by
+       repo or local checkout path
+    3. Global values in config.toml
+    4. Hardcoded defaults
+
+    Shares config.toml (``WITAN_CONFIG`` / ``~/.config/witan/config.toml``)
+    and the ``[targets.<name>]`` tables with witan (witan-council) — the same
+    target block can carry witan's ``server``/``graph``/``token`` alongside
+    this server's ``code_dir``, routed together. See ``witan.config.load()``'s
+    docstring for the full ``match_paths``/``match_repos``/``match_hosts``/
+    ``match_orgs`` precedence (shared logic: ``witan_core.target_config``).
+
+    Raises ValueError for an explicitly-requested target that is not defined.
+    """
+    file_cfg = _load_toml()
+    targets = _parse_targets(file_cfg)
+
+    explicit = target or os.environ.get("WITAN_TARGET")
+    if explicit:
+        selected = next((t for t in targets if t.name == explicit), None)
+        if selected is None:
+            available = ", ".join(t.name for t in targets) or "(none defined)"
+            raise ValueError(f"Unknown target {explicit!r}. Available: {available}")
+    else:
+        selected = match_target(
+            targets, repo_uri=repo_module.detect(), local_path=local_project_path()
+        )
+
+    raw_code_dir = _first(
+        os.environ.get("WITAN_CODE_DIR"),
+        selected.code_dir if selected else None,
+        file_cfg.get("code_dir"),
+        default=str(_DEFAULT_CODE_DIR),
+    )
+
+    return Config(
+        code_dir=Path(raw_code_dir).expanduser(),
+        author=_first(
+            os.environ.get("WITAN_AUTHOR"),
+            selected.author if selected else None,
+            file_cfg.get("author"),
+            os.environ.get("USER"),
+            default="unknown",
+        ),
+        queries_dir=_QUERIES_DIR,
+        schema_file=_SCHEMA_FILE,
+        bridge_schema_file=_BRIDGE_SCHEMA_FILE,
+        target_name=selected.name if selected else None,
+    )
+
+
+def sanitize_slug(slug: str) -> str:
+    """Make a repo slug safe for use as a LOCAL filename / branch-name component.
+
+    Emits underscores (``[/:]+`` → ``_``). Fine for local ``<slug>.omni`` store
+    dirs and per-repo branch prefixes, but NOT valid as a shared-cluster graph
+    id — omnigraph graph ids must match ``^[a-zA-Z0-9-]{1,64}$`` (no
+    underscores). Use :func:`graph_id` to derive the cluster ``--graph`` id.
+    """
+    return re.sub(r"[/:]+", "_", slug).strip("_")
+
+
+# ── Shared-cluster graph id ──────────────────────────────────────────────────
+#
+# On the deployed omnigraph-server, each repo's code graph is a distinct cluster
+# graph addressed as `--server <url> --graph <id>`. `graph_id()` is the CANONICAL
+# repo-URI → graph-id function.
+#
+# SHARED CONTRACT — this exact algorithm is mirrored by ol-infrastructure's
+# Pulumi provisioning (toolhive_witan/data_tier.py, which declares each
+# `code-<repo>` graph in the cluster.yaml ConfigMap). witan-code selects the
+# `--graph` id and provisioning declares the same id; they MUST agree
+# byte-for-byte or a client will address a graph the cluster never created. Any
+# change here has to land in lockstep on both sides — see task
+# tk-code-graph-deployment-topology-shared-per-repo-c-cac400.
+CODE_GRAPH_PREFIX = "code-"
+# The shared cross-repo bridge graph (Layer 2.5), analogous to the local
+# `_bridge.omni` store. Fixed id, not derived from any repo.
+BRIDGE_GRAPH_ID = "code-bridge"
+# omnigraph's graph-id constraint. Enforced by construction in `graph_id`.
+_GRAPH_ID_MAX_LEN = 64
+GRAPH_ID_RE = re.compile(r"^[a-zA-Z0-9-]{1,64}$")
+
+
+def graph_id(repo: str) -> str:
+    """Canonical cluster graph-id for ``repo``'s code graph.
+
+    e.g. ``https://github.com/mitodl/ol-django`` → ``code-github-com-mitodl-ol-django``.
+
+    Strip the URI scheme, collapse every run of non-alphanumerics to ``-``,
+    lowercase, and prefix ``code-``. The result always satisfies
+    :data:`GRAPH_ID_RE`. Slugs that would exceed :data:`_GRAPH_ID_MAX_LEN` are
+    truncated and disambiguated with a hash of the full repo URI (so distinct
+    long repos never collide on the same id).
+    """
+    body = re.sub(r"(?i)^[a-z][a-z0-9+.-]*://", "", repo)  # strip scheme
+    body = re.sub(r"[^a-zA-Z0-9]+", "-", body).strip("-").lower()
+    candidate = f"{CODE_GRAPH_PREFIX}{body}"
+    if len(candidate) <= _GRAPH_ID_MAX_LEN:
+        return candidate
+    digest = hashlib.sha256(repo.encode()).hexdigest()[:8]
+    keep = _GRAPH_ID_MAX_LEN - len(CODE_GRAPH_PREFIX) - len(digest) - 1
+    return f"{CODE_GRAPH_PREFIX}{body[:keep].strip('-')}-{digest}"
+
+
+def store_path(slug: str, code_dir: Path | None = None) -> Path:
+    """Resolve the per-repo store path for ``slug``."""
+    base = code_dir or load().code_dir
+    return base / f"{sanitize_slug(slug)}.omni"
+
+
+def bridge_store_path(code_dir: Path | None = None) -> Path:
+    """Resolve the shared cross-repo bridge store path."""
+    base = code_dir or load().code_dir
+    return base / BRIDGE_STORE_NAME

{witan_code-0.4.0 → witan_code-0.6.0}/witan_code/elicit.py

@@ -44,7 +44,7 @@ async def choose_repo(
     doesn't match any candidate — returns ``None``, meaning "keep every
     match" (today's behavior, unchanged).
     """
-    answer = await text(ctx, message, default="")
+    answer = await text(ctx, message, default="", title="Repo")
     if not answer:
         return None
     normalized = answer.strip().casefold()

{witan_code-0.4.0 → witan_code-0.6.0}/witan_code/graph.py

@@ -29,12 +29,13 @@ class OmnigraphClient(_BaseOmnigraphClient):
         queries_dir: Path,
         token: str | None = None,
         branch: str | None = None,
+        graph_id: str | None = None,
     ) -> None:
         # Target omnigraph branch for query/mutate/load; None = the store's main
         # branch. Loads pass `--from main` so the branch forks lazily on first
         # write (docs/BRANCH_INDEXING.md).
         self.branch = branch
-        super().__init__(graph_uri, queries_dir, token)
+        super().__init__(graph_uri, queries_dir, token, graph_id=graph_id)
 
     def load(self, records: list[dict], mode: str = "merge") -> None:
         """Bulk-load node/edge records via one ``omnigraph load`` call.

{witan_code-0.4.0 → witan_code-0.6.0}/witan_code/repo.py

@@ -12,8 +12,13 @@ def detect(override: str | None = None, start: Path | None = None) -> str | None
     Return a canonical repo key (HTTPS URI) for ``start`` (or the cwd).
 
     Resolution order:
-      1. ``override`` parameter (explicit caller value)
-      2. ``WITAN_REPO`` environment variable
+      1. ``override`` parameter (explicit caller value) — canonicalized the
+         same way an auto-detected remote is (see ``normalise``); an explicit
+         empty string means "no repo scope"
+      2. ``WITAN_REPO`` environment variable — canonicalized the same way; an
+         explicit empty string also disables auto-detection here, matching
+         witan-council's ``repo.detect`` (e.g. set in a global MCP server
+         config where the server CWD is not the session's repo)
       3. ``git remote get-url origin`` (handles worktrees and multi-valued
          config keys that ``configparser`` rejects)
       4. ``origin`` remote URL parsed from the nearest ``.git/config``
@@ -21,10 +26,11 @@ def detect(override: str | None = None, start: Path | None = None) -> str | None
       6. ``None`` — no repo context available
     """
     if override is not None:
-        return override or None
+        return normalise(override) if override else None
 
-    if env_repo := os.environ.get("WITAN_REPO"):
-        return env_repo
+    env_repo = os.environ.get("WITAN_REPO")
+    if env_repo is not None:
+        return normalise(env_repo) if env_repo else None
 
     base = start or Path.cwd()
 

{witan_code-0.4.0 → witan_code-0.6.0}/witan_code/schema/bridge-schema.pg

@@ -1,4 +1,7 @@
-// Cross-Repo Context Bridge (Layer 2.5) — shared LOCAL store (_bridge.omni).
+// Cross-Repo Context Bridge (Layer 2.5) — one shared store across all repos.
+//
+// Deployed as the `code-bridge` graph on the shared, S3-backed omnigraph-server
+// cluster (config.BRIDGE_GRAPH_ID); locally it is the `_bridge.omni` store.
 //
 // One flat node per interface binding. Cross-repo linkages are computed by
 // GROUPING bindings on (kind, key_norm) where roles/repos differ — there are
@@ -8,7 +11,8 @@
 // run + every PostToolUse reindex hook). Flat bindings are each scoped to their
 // own repo+file, so concurrent writers never touch the same row.
 //
-// Local-only and re-derivable, like the per-repo Layer-2 stores; never synced.
+// Re-derivable, like the per-repo Layer-2 graphs; seed the shared copy by
+// re-indexing on the server or export→load, never by copying a local store to S3.
 //
 // Id convention:
 //   InterfaceBinding.slug = repo|file|kind|key_norm|role|symbol_id

{witan_code-0.4.0 → witan_code-0.6.0}/witan_code/schema/code-schema.pg

@@ -1,6 +1,11 @@
 // Code Graph (Layer 2) — per-repo tree-sitter-derived symbol graph.
 //
-// One store per repository, kept LOCAL only (never synced to team S3).
+// One graph per repository. Deployed as a distinct graph on the shared,
+// S3-backed omnigraph-server cluster, addressed as `--graph code-<repo>` (the
+// canonical id from witan_code.config.graph_id); a local `<slug>.omni` store is
+// the standalone/dev fallback. The graph is re-derivable from source either way,
+// so seed the shared copy by re-indexing on the server or export→load — never
+// copy a local store up to S3 (Lance embeds root-relative paths).
 // Composes with witan (Layer 1) via soft symbol-ID references:
 // Layer-1 nodes store symbol ids of the form `repo#path::Qualified.Name`,
 // which resolve here without a hard cross-store edge.

{witan_code-0.4.0 → witan_code-0.6.0}/witan_code/server.py

@@ -236,6 +236,7 @@ async def _confirm_and_reindex(
         f"No code graph indexed yet for {repo}. Index it now? "
         "(may take a while on a large repo)",
         default_when_unsupported=False,
+        title="Index now?",
     )
     if not ok:
         return None
@@ -260,6 +261,7 @@ async def _confirm_and_reindex_bridge(ctx: Context | None) -> OmnigraphClient |
         f"No cross-repo graph indexed yet. Index the current repo ({repo}) "
         "now to start building it?",
         default_when_unsupported=False,
+        title="Index now?",
     )
     if not ok:
         return None
@@ -497,6 +499,7 @@ async def code_symbols_in_file(
             "No repo detected for this file (not in a git repo, or no remote). "
             "Enter its canonical repo URI (e.g. https://github.com/org/name):",
             default="",
+            title="Repo URI",
         )
         if not slug:
             return []

witan_code-0.4.0/witan_code/config.py

@@ -1,65 +0,0 @@
-import os
-import re
-from dataclasses import dataclass
-from pathlib import Path
-
-# Bundled query files, resolved relative to this file.
-_QUERIES_DIR = Path(__file__).parent / "queries"
-_SCHEMA_FILE = Path(__file__).parent / "schema" / "code-schema.pg"
-_BRIDGE_SCHEMA_FILE = Path(__file__).parent / "schema" / "bridge-schema.pg"
-_DEFAULT_CODE_DIR = Path.home() / ".local" / "share" / "witan" / "code"
-
-# Filename of the single shared cross-repo bridge store, a sibling of the
-# per-repo `<slug>.omni` stores in code_dir. Not routed through sanitize_slug
-# (whose .strip("_") would eat the leading underscore); no real repo slug
-# resolves to this name.
-BRIDGE_STORE_NAME = "_bridge.omni"
-
-
-@dataclass(frozen=True)
-class Config:
-    code_dir: Path
-    """Directory holding per-repo code stores (one ``<slug>.omni`` each)."""
-
-    author: str
-    """Attribution string (carried for parity with Layer 1; unused on inserts)."""
-
-    queries_dir: Path
-    """Directory containing code_read.gq, code_mutations.gq, delete.gq."""
-
-    schema_file: Path
-    """Path to code-schema.pg, used to lazily init a per-repo store."""
-
-    bridge_schema_file: Path
-    """Path to bridge-schema.pg, used to lazily init the shared bridge store."""
-
-
-def load() -> Config:
-    """Load config from environment. All variables are optional with defaults."""
-    return Config(
-        code_dir=Path(os.environ.get("WITAN_CODE_DIR", str(_DEFAULT_CODE_DIR))),
-        author=os.environ.get(
-            "WITAN_AUTHOR",
-            os.environ.get("USER", "unknown"),
-        ),
-        queries_dir=_QUERIES_DIR,
-        schema_file=_SCHEMA_FILE,
-        bridge_schema_file=_BRIDGE_SCHEMA_FILE,
-    )
-
-
-def sanitize_slug(slug: str) -> str:
-    """Make a repo slug safe for use as a filename component."""
-    return re.sub(r"[/:]+", "_", slug).strip("_")
-
-
-def store_path(slug: str, code_dir: Path | None = None) -> Path:
-    """Resolve the per-repo store path for ``slug``."""
-    base = code_dir or load().code_dir
-    return base / f"{sanitize_slug(slug)}.omni"
-
-
-def bridge_store_path(code_dir: Path | None = None) -> Path:
-    """Resolve the shared cross-repo bridge store path."""
-    base = code_dir or load().code_dir
-    return base / BRIDGE_STORE_NAME