Skip to content

Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.

fix(mcp): read freshness and live files from the served checkout (#3644)

Swati Ahuja9fa02e61b241
diff --git a/packages/server/src/repowise/server/mcp_server/__init__.py b/packages/server/src/repowise/server/mcp_server/__init__.py
index 96521f6c1..2edf54d2d 100644
--- a/packages/server/src/repowise/server/mcp_server/__init__.py
+++ b/packages/server/src/repowise/server/mcp_server/__init__.py
@@ -330,6 +330,7 @@ _STATE_NAMES = frozenset(
"_decision_store",
"_fts",
"_repo_path",
+ "_served_repo_id",
"_vector_store_ready",
"_lancedb_ready",
"_registry",
diff --git a/packages/server/src/repowise/server/mcp_server/_hit_symbols.py b/packages/server/src/repowise/server/mcp_server/_hit_symbols.py
index e408e3b83..fd23f76a2 100644
--- a/packages/server/src/repowise/server/mcp_server/_hit_symbols.py
+++ b/packages/server/src/repowise/server/mcp_server/_hit_symbols.py
@@ -22,6 +22,7 @@ from repowise.core.persistence.database import get_session
from repowise.core.persistence.models import WikiSymbol
from repowise.server.mcp_server._edit_sites import MAX_TEXT_CHARS, _import_lines, _read_lines
from repowise.server.mcp_server._helpers import _get_repo
+from repowise.server.mcp_server._meta import served_root
from repowise.server.mcp_server._page_paths import hit_file_path
from repowise.server.mcp_server._query_terms import content_terms
from repowise.server.mcp_server.tool_search_symbols import _tokens
@@ -183,7 +184,7 @@ async def _attach(ctx, query: str, rows: list[dict]) -> None:
wanted.setdefault(path, [span for *_, span in ranked])
if not wanted:
return
- root = Path(repo.local_path or ctx.path)
+ root = Path(served_root(repo, ctx.path))
sampled = await asyncio.to_thread(_sample_lines, root, list(wanted.items()), terms)
for hit in rows:
if found := sampled.get(targets.get(id(hit), "")):
diff --git a/packages/server/src/repowise/server/mcp_server/_index_state.py b/packages/server/src/repowise/server/mcp_server/_index_state.py
index 1362f0714..383832abc 100644
--- a/packages/server/src/repowise/server/mcp_server/_index_state.py
+++ b/packages/server/src/repowise/server/mcp_server/_index_state.py
@@ -12,6 +12,8 @@ from __future__ import annotations
import os
from typing import Any
+from repowise.server.mcp_server._meta import served_root
+
_STATE_FILE = os.path.join(".repowise", "state.json")
@@ -19,7 +21,7 @@ def index_state_key(repository: Any) -> str:
"""Head commit, row write time and the end-of-run state file's mtime."""
head = getattr(repository, "head_commit", None) or ""
updated = getattr(repository, "updated_at", None) or ""
- local_path = getattr(repository, "local_path", None)
+ local_path = served_root(repository)
saved = ""
if local_path:
try:
diff --git a/packages/server/src/repowise/server/mcp_server/_line_hits.py b/packages/server/src/repowise/server/mcp_server/_line_hits.py
index 9ee5f82a7..2c2e9b780 100644
--- a/packages/server/src/repowise/server/mcp_server/_line_hits.py
+++ b/packages/server/src/repowise/server/mcp_server/_line_hits.py
@@ -47,6 +47,7 @@ from repowise.server.mcp_server._helpers import (
is_excluded,
read_repo_file_text,
)
+from repowise.server.mcp_server._meta import served_root
from repowise.server.mcp_server._query_shape import (
_canonical_symbol_query,
_identifier_candidates,
@@ -405,7 +406,7 @@ async def _attach(
spec = _get_exclude_spec(ctx.path)
async with get_session(ctx.session_factory) as session:
repository = await _get_repo(session)
- root = Path(repository.local_path or ctx.path)
+ root = Path(served_root(repository, ctx.path))
nodes = []
if candidates:
found = await _exact_symbols(session, repository.id, query, candidates)
diff --git a/packages/server/src/repowise/server/mcp_server/_meta.py b/packages/server/src/repowise/server/mcp_server/_meta.py
index aa329ad30..b516b5fff 100644
--- a/packages/server/src/repowise/server/mcp_server/_meta.py
+++ b/packages/server/src/repowise/server/mcp_server/_meta.py
@@ -71,6 +71,34 @@ def full_meta(tool: str | None = None) -> bool:
_STALE_AGE_FLOOR_DAYS = 90
+def served_root(repository: Any, ctx_path: str | Path | None = None) -> str | None:
+ """The checkout to read live HEAD, state.json and files from for *repository*.
+
+ The stored ``local_path`` is where the repo was indexed; a moved or copied
+ repo keeps the old value, so reads through it see another tree. A
+ single-repo server's own path wins for the row its own store identifies
+ (``_state._served_repo_id``) when that path holds ``.repowise/`` and
+ ``.git`` (a file in a worktree). Any other row, such as another repo in a
+ shared store, keeps its stored path; *ctx_path* stands in only when the
+ row has none. The row is never rewritten.
+ """
+ from repowise.server.mcp_server import _state
+
+ served = _state._repo_path
+ if (
+ served
+ and _state._registry is None
+ and _state._served_repo_id is not None
+ and getattr(repository, "id", None) == _state._served_repo_id
+ ):
+ root = Path(served)
+ if (root / ".repowise").is_dir() and (root / ".git").exists():
+ return str(root)
+ # Ceiling: a workspace server keeps each repo's stored path; giving it
+ # the same override needs the registry to record each store's one row.
+ return getattr(repository, "local_path", None) or (str(ctx_path) if ctx_path else None)
+
+
def read_live_head(local_path: str | None) -> str | None:
"""Read the repo's current git HEAD SHA via plain file I/O.
@@ -444,7 +472,9 @@ def reverted_targets(local_path: str | None, targets: list[str] | None) -> list[
return out
-def freshness_from_repo(repository: Any | None, targets: list[str] | None = None) -> dict[str, Any]:
+def freshness_from_repo(
+ repository: Any | None, targets: list[str] | None = None, root: str | None = None
+) -> dict[str, Any]:
"""Return a minimal freshness dict for the given Repository row.
Calibrated to fire ``stale_warning`` rarely so the agent keeps trusting
@@ -504,7 +534,8 @@ def freshness_from_repo(repository: Any | None, targets: list[str] | None = None
age_days = max(0, (datetime.now(UTC) - ua).days)
out["index_age_days"] = age_days
- local_path = getattr(repository, "local_path", None)
+ # ``root``: the served checkout (see served_root), resolved here when omitted.
+ local_path = root or served_root(repository)
# Prefer state.json's last_sync_commit over a possibly-stale DB head_commit
# so freshness self-heals on read (see resolve_indexed_commit).
indexed_full = resolve_indexed_commit(
@@ -634,8 +665,9 @@ def build_meta(
if cached:
out["cached"] = True
if repository is not None:
- out.update(freshness_from_repo(repository, targets=targets))
- scope = index_scope_for_response(getattr(repository, "local_path", None))
+ root = served_root(repository)
+ out.update(freshness_from_repo(repository, targets=targets, root=root))
+ scope = index_scope_for_response(root)
# A complete digest restates the default; only a gap is news.
if scope is not None and (
full or _canonical_scope_requested() or scope.get("status") != "complete"
@@ -659,7 +691,7 @@ def build_meta_with_full_scope(**kwargs: Any) -> dict[str, Any]:
meta = {"contract_version": MCP_CONTRACT_VERSION, **build_meta(**kwargs)}
repository = kwargs.get("repository")
if repository is not None:
- scope = read_index_scope(getattr(repository, "local_path", None))
+ scope = read_index_scope(served_root(repository))
if scope is not None:
# The fingerprint is what makes a held copy checkable against a
# later digest, so the copy being held has to carry it too.
diff --git a/packages/server/src/repowise/server/mcp_server/_server.py b/packages/server/src/repowise/server/mcp_server/_server.py
index fc0bb2dab..4c5e72958 100644
--- a/packages/server/src/repowise/server/mcp_server/_server.py
+++ b/packages/server/src/repowise/server/mcp_server/_server.py
@@ -350,6 +350,24 @@ async def _cancel_task(task: asyncio.Task) -> None:
await task
+async def _served_repository_id(factory: Any) -> str | None:
+ """The one row a repo-local store holds, else ``None``.
+
+ Same rule as the CLI's moved-repo lookup: identity is inferred only from
+ the served checkout's own store, and only when it holds one repository.
+ """
+ from sqlalchemy import select
+
+ from repowise.core.persistence.models import Repository
+
+ try:
+ async with factory() as session:
+ rows = (await session.scalars(select(Repository.id).limit(2))).all()
+ except OperationalError:
+ return None
+ return rows[0] if len(rows) == 1 else None
+
+
async def _abort_startup(*tasks: asyncio.Task) -> None:
"""Undo the startup a lifespan raised out of, before it reached its teardown.
@@ -684,6 +702,9 @@ async def _lifespan(server: FastMCP):
engine, expire_on_commit=False, class_=AsyncSession
)
+ if _state._repo_path and configured_db_url is None:
+ _state._served_repo_id = await _served_repository_id(_state._session_factory)
+
_state._fts = FullTextSearch(engine)
try:
await _state._fts.ensure_index()
@@ -713,6 +734,7 @@ async def _lifespan(server: FastMCP):
await _cancel_task(_bg_task)
await _cancel_task(_warm_task)
_state._lancedb_ready = None
+ _state._served_repo_id = None
await engine.dispose()
# _decision_store is an alias for _vector_store — close only once.
diff --git a/packages/server/src/repowise/server/mcp_server/_state.py b/packages/server/src/repowise/server/mcp_server/_state.py
index ce426dc0d..6d0b2e902 100644
--- a/packages/server/src/repowise/server/mcp_server/_state.py
+++ b/packages/server/src/repowise/server/mcp_server/_state.py
@@ -18,6 +18,10 @@ _vector_store: Any = None
_decision_store: Any = None
_fts: Any = None
_repo_path: str | None = None
+# Id of the row the served checkout's own store holds for it, when that store
+# holds exactly one (set by _lifespan). Only that row's live reads follow
+# ``_repo_path`` when its stored local_path differs; see _meta.served_root.
+_served_repo_id: str | None = None
# When set, the server skips workspace auto-detection even if the path is
# inside a workspace root. This backs the CLI's `--no-workspace` escape hatch.
_force_single_repo: bool = False
diff --git a/packages/server/src/repowise/server/mcp_server/tool_context/targets.py b/packages/server/src/repowise/server/mcp_server/tool_context/targets.py
index b272b449f..8df658c23 100644
--- a/packages/server/src/repowise/server/mcp_server/tool_context/targets.py
+++ b/packages/server/src/repowise/server/mcp_server/tool_context/targets.py
@@ -56,7 +56,7 @@ from repowise.server.mcp_server._helpers import (
read_repo_file_text,
)
from repowise.server.mcp_server._index_state import index_state_key
-from repowise.server.mcp_server._meta import uncommitted_targets
+from repowise.server.mcp_server._meta import served_root, uncommitted_targets
from repowise.server.mcp_server._references import path_identity, symbol_identity
from repowise.server.mcp_server._symbol_lookup import (
nearest_symbol_ids,
@@ -1312,7 +1312,7 @@ async def _resolve_one_target(
freshness["freshness_status"] = None
freshness["is_stale"] = None
if file_path_for_git and uncommitted_targets(
- getattr(repository, "local_path", None), [file_path_for_git]
+ served_root(repository, repo_root), [file_path_for_git]
):
freshness["working_tree"] = "modified"
result_data["freshness"] = freshness
@@ -1365,7 +1365,7 @@ async def _resolve_one_target(
want_callees=want_callees,
exclude_spec=exclude_spec,
collector=collector,
- repo_root=repo_root or getattr(repository, "local_path", None),
+ repo_root=served_root(repository, repo_root),
)
# --- Reference edit set: every live site naming the symbol ---
@@ -1384,7 +1384,7 @@ async def _resolve_one_target(
key=lambda g: (g.node_id != symbol_node_id, g.node_id),
default=None,
)
- root = repo_root or getattr(repository, "local_path", None)
+ root = served_root(repository, repo_root)
if ref_node is not None and root:
result_data["references"] = await reference_edit_set(
session, repo_id, root, ref_node, collector
diff --git a/packages/server/src/repowise/server/mcp_server/tool_risk/assessment.py b/packages/server/src/repowise/server/mcp_server/tool_risk/assessment.py
index 942e16bac..24929cb65 100644
--- a/packages/server/src/repowise/server/mcp_server/tool_risk/assessment.py
+++ b/packages/server/src/repowise/server/mcp_server/tool_risk/assessment.py
@@ -24,6 +24,7 @@ from repowise.server.mcp_server._helpers import (
filter_dicts_by_key,
is_excluded,
)
+from repowise.server.mcp_server._meta import served_root
from repowise.server.repo_paths import normalize_target_path
#: A file carrying this many counted bug fixes reads as bug-prone. Same trigger
@@ -447,6 +448,7 @@ async def _assess_one_target(
collector: OmissionCollector | None = None,
include_graph: bool = False,
as_of_ts: datetime | None = None,
+ repo_root: str | None = None,
) -> dict:
"""Assess risk for a single target file.
@@ -457,7 +459,8 @@ async def _assess_one_target(
repo_id = repository.id
result_data: dict[str, Any] = {"target": target}
- lookup_path = normalize_target_path(target, repo_root=repository.local_path)
+ repo_root = served_root(repository, repo_root)
+ lookup_path = normalize_target_path(target, repo_root=repo_root)
dependency_population = _dependency_population(
lookup_path, reverse_deps, node_meta, exclude_spec
)
@@ -580,7 +583,7 @@ async def _assess_one_target(
return {
"target": target,
"resolved": False,
- **await _unresolved_reason(target, lookup_path, repository.local_path),
+ **await _unresolved_reason(target, lookup_path, repo_root),
"risk_summary": (
f"{target} — not resolved to an indexed file; no risk signal was computed"
),
diff --git a/packages/server/src/repowise/server/mcp_server/tool_risk/get_risk.py b/packages/server/src/repowise/server/mcp_server/tool_risk/get_risk.py
index fdd88b768..649dbb3a7 100644
--- a/packages/server/src/repowise/server/mcp_server/tool_risk/get_risk.py
+++ b/packages/server/src/repowise/server/mcp_server/tool_risk/get_risk.py
@@ -36,6 +36,7 @@ from repowise.server.mcp_server._helpers import (
resolve_enum_argument,
)
from repowise.server.mcp_server._meta import build_meta as _build_meta
+from repowise.server.mcp_server._meta import served_root
from repowise.server.mcp_server._test_selection import (
SelectionUnavailableError,
files_change,
@@ -271,7 +272,8 @@ async def _gather_evidence(
repo_id = repository.id
# A card walks from the target as given and reads links under its
# normalized path, so both spellings are roots.
- roots = {*targets, *(normalize_target_path(t, repository.local_path) for t in targets)}
+ repo_root = served_root(repository, ctx.path)
+ roots = {*targets, *(normalize_target_path(t, repo_root) for t in targets)}
graph = await _load_dependency_graph(session, repo_id, roots)
# Repo-wide, so computed once for every target's bus-factor calibration.
@@ -299,6 +301,7 @@ async def _gather_evidence(
collector,
include_graph,
as_of_ts=as_of_ts,
+ repo_root=repo_root,
)
for t in targets
]
diff --git a/packages/server/src/repowise/server/mcp_server/tool_why/archaeology.py b/packages/server/src/repowise/server/mcp_server/tool_why/archaeology.py
index 197e41903..6ceefe7d8 100644
--- a/packages/server/src/repowise/server/mcp_server/tool_why/archaeology.py
+++ b/packages/server/src/repowise/server/mcp_server/tool_why/archaeology.py
@@ -18,7 +18,7 @@ async def _git_archaeology_fallback(
file_path: str,
git_meta: Any | None,
all_git_meta: list,
- repository: Any,
+ repo_root: str | None,
) -> dict:
"""When no decisions govern a file, mine git history for intent signals."""
result: dict[str, Any] = {"triggered": True}
@@ -34,9 +34,8 @@ async def _git_archaeology_fallback(
# --- Layer 3: Live git log (when local repo exists) ---
git_log_results = []
- local_path = getattr(repository, "local_path", None)
- if local_path and (Path(local_path) / ".git").exists():
- git_log_results = await _run_git_log(local_path, file_path, stem)
+ if repo_root and (Path(repo_root) / ".git").exists():
+ git_log_results = await _run_git_log(repo_root, file_path, stem)
result["git_log"] = git_log_results
# --- Summary ---
diff --git a/packages/server/src/repowise/server/mcp_server/tool_why/path_mode.py b/packages/server/src/repowise/server/mcp_server/tool_why/path_mode.py
index b42d9bb48..cde93302f 100644
--- a/packages/server/src/repowise/server/mcp_server/tool_why/path_mode.py
+++ b/packages/server/src/repowise/server/mcp_server/tool_why/path_mode.py
@@ -27,6 +27,7 @@ from repowise.server.mcp_server._helpers import (
is_excluded,
)
from repowise.server.mcp_server._meta import build_meta as _build_meta
+from repowise.server.mcp_server._meta import served_root
from repowise.server.mcp_server._why_evidence import annotate_response_evidence_async
from repowise.server.mcp_server.tool_why.archaeology import _git_archaeology_fallback
from repowise.server.mcp_server.tool_why.caps import (
@@ -244,7 +245,7 @@ async def _add_ungoverned_evidence(
path,
git_meta,
all_git_meta,
- repository,
+ served_root(repository, repo_path),
)
# The "why" may live in a code comment.
rationale = _mine_rationale(
@@ -273,6 +274,7 @@ async def _build_target_context(
# Load all git metadata for cross-file search
all_git_meta_list = await _all_git_metadata(session2, repository.id)
+ root = served_root(repository, ctx.path)
target_context: dict[str, Any] = {}
for t in targets:
target_context[t] = await _target_card(
@@ -280,7 +282,7 @@ async def _build_target_context(
all_decisions,
target_git.get(t),
all_git_meta_list,
- repository,
+ root,
accepted or set(),
)
return target_context
@@ -306,7 +308,7 @@ async def _target_card(
all_decisions: list,
git_m: Any | None,
all_git_meta_list: list,
- repository: Any,
+ repo_root: str | None,
accepted_ids: set[str],
) -> dict[str, Any]:
"""One target's card: its rules, its candidates, its origin, and archaeology."""
@@ -342,7 +344,7 @@ async def _target_card(
t,
git_m,
all_git_meta_list,
- repository,
+ repo_root,
)
return ctx_entry
diff --git a/tests/unit/server/mcp/test_answer_projection.py b/tests/unit/server/mcp/test_answer_projection.py
index 850f8088c..8f590118f 100644
--- a/tests/unit/server/mcp/test_answer_projection.py
+++ b/tests/unit/server/mcp/test_answer_projection.py
@@ -66,7 +66,7 @@ async def test_fresh_and_cached_answers_share_one_external_contract(setup_mcp, m
provider = _Provider("Authentication is implemented in src/auth/service.py.")
monkeypatch.setattr(answer_mod, "_resolve_provider_for_answer", lambda _path: provider)
- def freshness(_repository, targets=None):
+ def freshness(_repository, targets=None, root=None):
result = {"index_behind": True}
if "src/auth/middleware.py" in (targets or []):
result["stale_warning"] = "dropped evidence changed"
diff --git a/tests/unit/server/mcp/test_search_line_hits.py b/tests/unit/server/mcp/test_search_line_hits.py
index 8773d7a32..a34810b4c 100644
--- a/tests/unit/server/mcp/test_search_line_hits.py
+++ b/tests/unit/server/mcp/test_search_line_hits.py
@@ -3,13 +3,14 @@
from __future__ import annotations
import inspect
+import shutil
import subprocess
from datetime import UTC, datetime
import pytest
from repowise.core.persistence.models import GraphEdge, GraphNode
-from repowise.server.mcp_server import _edit_sites, _line_hits, _meta
+from repowise.server.mcp_server import _edit_sites, _line_hits, _meta, _state
from repowise.server.mcp_server._budget import enforce_response_budget
from repowise.server.mcp_server.tool_search import search_codebase
@@ -29,6 +30,9 @@ _FILES = {
}
+_REAL_DIRTY = _meta._working_tree_dirty_paths
+
+
def _dirty(monkeypatch, paths: frozenset[str]) -> None:
for module in (_edit_sites, _meta):
monkeypatch.setattr(module, "_working_tree_dirty_paths", lambda _p: paths)
@@ -170,6 +174,29 @@ async def test_uncommitted_unindexed_file_is_scanned(tree):
assert out["complete"] is True
+async def test_unindexed_file_is_read_from_the_served_checkout(
+ tree, setup_mcp, tmp_path_factory, monkeypatch
+):
+ # The stored local_path (tree) is an older copy; the server serves another.
+ tree_repo_id = setup_mcp
+ for module in (_edit_sites, _meta):
+ monkeypatch.setattr(module, "_working_tree_dirty_paths", _REAL_DIRTY)
+ served = tmp_path_factory.mktemp("served") / "repo"
+ shutil.copytree(tree, served)
+ (served / ".repowise").mkdir()
+ (served / "app" / "later.py").write_text(
+ "from pkg.catalog import backend_of\n\nbackend_of('x')\n", encoding="utf-8"
+ )
+ monkeypatch.setattr(_state, "_repo_path", str(served))
+ monkeypatch.setattr(_state, "_served_repo_id", tree_repo_id)
+ _meta._dirty_paths_cache.clear()
+
+ out = await search_codebase("backend_of", mode="symbol")
+
+ assert {"app/later.py", "app/widget.py"} <= {r["path"] for r in out["lines"]}
+
+
@pytest.mark.asyncio
async def test_binary_holding_the_token_and_undecodable_text_are_reported(tree):
(tree / "logo.png").write_bytes(b"\x89PNG\x00\x00none")
diff --git a/tests/unit/server/mcp/test_served_root.py b/tests/unit/server/mcp/test_served_root.py
new file mode 100644
index 000000000..e0e387981
--- /dev/null
+++ b/tests/unit/server/mcp/test_served_root.py
@@ -0,0 +1,103 @@
+"""Live reads follow the checkout the server serves, not the stored ``local_path``.
+
+A moved or copied repo keeps its old ``local_path`` in the index. Reading HEAD,
+state.json or the working tree through it reports the old tree, so a dirty
+file in the served checkout would read as fresh and complete. Only the row the
+served store identifies follows the served path; any other row keeps its own.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+import types
+from pathlib import Path
+
+import pytest
+
+from repowise.core.persistence.models import Repository
+from repowise.server.mcp_server import _meta, _server, _state
+from tests.unit.cli.test_update_e2e import _git
+from tests.unit.server.mcp.test_working_tree_freshness import _make_repo
+
+
+def _indexed(repo: Path) -> None:
+ head = _git(repo, "rev-parse", "HEAD")
+ (repo / ".repowise").mkdir(exist_ok=True)
+ (repo / ".repowise" / "state.json").write_text(json.dumps({"last_sync_commit": head}))
+
+
+def served(monkeypatch):
+ def serve(path: Path | None, repo_id: str | None = "served", *, workspace: bool = False):
+ monkeypatch.setattr(_state, "_repo_path", str(path) if path else None)
+ monkeypatch.setattr(_state, "_served_repo_id", repo_id)
+ monkeypatch.setattr(_state, "_registry", object() if workspace else None)
+ _meta._dirty_paths_cache.clear()
+
+ return serve
+
+
[email protected]("old_location", ["gone", "other_checkout"])
+def test_moved_repo_reports_dirty_files_of_the_served_checkout(
+ tmp_path: Path, served, old_location: str
+) -> None:
+ old = _make_repo(tmp_path)
+ _indexed(old)
+ new = tmp_path / "moved"
+ shutil.copytree(old, new)
+ if old_location == "gone":
+ shutil.rmtree(old, ignore_errors=True)
+ (new / "pricing.py").write_text("def base_price():\n return 99173\n")
+ row = types.SimpleNamespace(
+ id="served", updated_at=None, local_path=str(old), head_commit=None
+ )
+ served(new)
+
+ out = _meta.build_meta(repository=row, targets=["pricing.py"])
+
+ assert out["working_tree_dirty"] == 1
+ assert "repowise update --working-tree" in out["stale_warning"]
+ assert out["index_behind"] is False
+
+
+def test_another_row_keeps_its_own_checkout(tmp_path: Path, served) -> None:
+ # A shared store: the server serves one repo, the call reads another.
+ mine = _make_repo(tmp_path)
+ _indexed(mine)
+ other = tmp_path / "other"
+ shutil.copytree(mine, other)
+ (mine / "pricing.py").write_text("def base_price():\n return 99173\n")
+ row = types.SimpleNamespace(id="other", updated_at=None, local_path=str(other), head_commit=None)
+ served(mine)
+
+ assert _meta.served_root(row, mine) == str(other)
+ assert "working_tree_dirty" not in _meta.build_meta(repository=row, targets=["pricing.py"])
+
+
+def test_the_served_path_needs_an_index_and_a_single_repo_server(tmp_path: Path, served) -> None:
+ indexed = tmp_path / "indexed"
+ bare = tmp_path / "bare"
+ bare.mkdir()
+ (bare / ".git").write_text("gitdir: elsewhere\n")
+ row = types.SimpleNamespace(id="served", local_path=str(indexed))
+ served(bare)
+
+ assert _meta.served_root(row) == str(indexed)
+ (bare / ".repowise").mkdir()
+ # A worktree's .git is a file; it still counts.
+ assert _meta.served_root(row) == str(bare)
+ served(bare, workspace=True)
+ assert _meta.served_root(row) == str(indexed)
+ served(bare, repo_id=None)
+ assert _meta.served_root(row) == str(indexed)
+
+
+async def test_the_served_row_is_the_one_row_its_store_holds(factory, session, repo_id) -> None:
+ await session.commit()
+ assert await _server._served_repository_id(factory) == repo_id
+
+ session.add(Repository(id="second", name="second", local_path="/elsewhere"))
+ await session.commit()
+ assert await _server._served_repository_id(factory) is None