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(dead-code): serve every surface through one cross-repo read, and lower confidence only on a contract link (#4375)

Raghav Chamadiya6009a92dbb1d
diff --git a/docs/architecture/dead-code.md b/docs/architecture/dead-code.md
index bf2277764..ee05cdf5b 100644
--- a/docs/architecture/dead-code.md
+++ b/docs/architecture/dead-code.md
@@ -177,7 +177,9 @@ built from the `risk_factors.py` constants. The TypeScript mirror is
`DEAD_CODE_CONFIDENCE` in `packages/types/src/dead-code.ts`, so CLI, web and
MCP tier identically.
-`adjust_cross_repo` runs after tiering in workspace mode: a file with
-cross-repo co-change partners gets confidence `* 0.5` and a
-`cross_repo_note`; otherwise an `unused_export` in a repo that other repos
-depend on as a package gets `* 0.3`.
+`serve_findings` is the one read the MCP tool, the REST routes and the CLI
+share: it applies `cross_repo_cut` to each stored row, then the filters, and
+tiering reads the result. A file another repo's contract link points at gets
+confidence `* 0.3`. Cross-repo co-change partners, or an `unused_export` in a
+repo other repos depend on as a package, keep the confidence. Each adds a
+`cross_repo_note` and withdraws `safe_to_delete`.
diff --git a/docs/layers/DEAD_CODE.md b/docs/layers/DEAD_CODE.md
index 35b3e1635..1c3d57558 100644
--- a/docs/layers/DEAD_CODE.md
+++ b/docs/layers/DEAD_CODE.md
@@ -77,11 +77,11 @@ finding's evidence saying why.
| Medium | `0.4` to `0.7` | Likely unused, but something indirect may reach it. Review first. |
| Low | `< 0.4` | Plausibly used at runtime (dynamic loading, reflection, published API). Investigate first. |
-The CLI, the dashboard and `get_dead_code` use the same tier floors. The
-default `min_confidence` is `0.4` everywhere, which hides the low tier unless
-you ask for it. In a workspace, only `get_dead_code` applies the
-[cross-repo cut](#workspaces), after that floor, so it can place a finding in a
-lower tier than the CLI and dashboard do, including below `0.4`.
+The dead-code lists and summaries of the CLI, the dashboard and
+`get_dead_code` use the same tier floors and the same
+[cross-repo cut](#workspaces), so a finding lands in the same tier on each.
+The default `min_confidence` is `0.4` everywhere, which hides the low tier
+unless you ask for it.
### `safe_to_delete`
@@ -171,24 +171,25 @@ deleting anything.
## Workspaces
In a workspace, a file dead inside its own repo may be the surface another repo
-depends on. `get_dead_code` checks each finding against the cross-repo data
-before returning it:
-
-- If the file changes together with files in other repos (git co-change),
- confidence is halved and the finding gains a `cross_repo_note` naming those
- repos.
-- Otherwise, if the finding is an unused export and another repo depends on
- this one as a package, confidence is cut to 30% of its value with a note to
- verify consumers. The note names a dependent only when its package link
- covers the file's package (or records no manifest) or its contract link (an
- HTTP route, a generated client) points at the file. The cut applies either way, because package links
- can miss a consumer.
-
-The adjustment runs before tiering, so a lowered finding sits in the tier its
-new confidence names and is never safe to delete. `repo="all"` merges every workspace
-repo and tags each finding with its alias. The CLI has no cross-repo pass:
-`--repo <alias>` analyzes one repo in isolation (the primary repo by default).
-See [WORKSPACES.md](../scale/WORKSPACES.md) for how cross-repo data is built.
+depends on. The CLI, the dashboard and `get_dead_code` check each finding
+against the cross-repo data before the confidence floor and the tiers:
+
+- If another repo's contract link (an HTTP route, a generated client) points
+ at the file, confidence is cut to 30% of its value and the `cross_repo_note`
+ names the consumer.
+- Otherwise, if the file changes together with files in other repos (git
+ co-change), or the finding is an unused export and another repo depends on
+ this one as a package, the finding keeps its confidence and gains a note.
+ The note names a package dependent only when its link covers the file's
+ package (or records no manifest). These links say a consumer may exist, not
+ that one does.
+
+A finding with a note is never safe to delete, and a lowered one sits in the
+tier its new confidence names, so one cut below `0.4` is hidden by the default
+floor. The dashboard adds the note to the finding's evidence. `repo="all"` merges every
+workspace repo and tags each finding with its alias. The CLI analyzes one repo
+per run (the primary repo unless `--repo <alias>`), and `--no-workspace` skips
+the cut. See [WORKSPACES.md](../scale/WORKSPACES.md) for how cross-repo data is built.
## Accuracy and limits
diff --git a/docs/reference/MCP_RESPONSE_FIELDS.md b/docs/reference/MCP_RESPONSE_FIELDS.md
index 74d17920a..85f9b2ca5 100644
--- a/docs/reference/MCP_RESPONSE_FIELDS.md
+++ b/docs/reference/MCP_RESPONSE_FIELDS.md
@@ -701,7 +701,7 @@ Per-file `covered_line_count`, `total_coverable_lines` (targeted adds `covered_l
| `limit_note` | A `limit` over 25 was clamped |
- No language is gated; dead code on Java, C#, C, C++, Kotlin and Swift is preview, labelled in `_meta.preview`.
-- Workspace mode lowers confidence on findings another repo imports.
+- In workspace mode a finding another repo may use is never `safe_to_delete`, and a contract link to its file also lowers its confidence.
- The 0.7 and 0.4 floors are shared by the CLI, web UI and this tool. See [DEAD_CODE.md](../layers/DEAD_CODE.md).
---
diff --git a/packages/cli/src/repowise/cli/commands/dead_code_cmd.py b/packages/cli/src/repowise/cli/commands/dead_code_cmd.py
index 5701d6396..defa41a22 100644
--- a/packages/cli/src/repowise/cli/commands/dead_code_cmd.py
+++ b/packages/cli/src/repowise/cli/commands/dead_code_cmd.py
@@ -3,6 +3,7 @@
from __future__ import annotations
import json
+from dataclasses import replace
from pathlib import Path
from typing import Any
@@ -22,7 +23,13 @@ from repowise.cli.helpers import (
from repowise.cli.output import notice_console
from repowise.core.analysis.dead_code.models import DeadCodeFindingData, DeadCodeReport
from repowise.core.analysis.dead_code.risk_factors import RISK_CAP_CONFIDENCE
-from repowise.core.analysis.dead_code.serving import safe_only_note
+from repowise.core.analysis.dead_code.serving import (
+ CrossRepoLookup,
+ ServedFinding,
+ is_safe,
+ safe_only_note,
+ serve_findings,
+)
from repowise.core.analysis.finding_registry import preview_lines
#: The floor ``init`` and ``update`` store findings at: they run the analyzer
@@ -149,6 +156,56 @@ def _analyze_live(repo_path: Path, config: dict, notices: Any) -> DeadCodeReport
return analyzer.analyze(config)
+def _cross_repo_inputs(
+ target: Any, repo_path: Path, no_workspace: bool
+) -> tuple[CrossRepoLookup | None, str | None]:
+ """The workspace data and alias the cross-repo cut reads for *repo_path*."""
+ if no_workspace or target.ws_root is None:
+ return None, None
+ from repowise.core.workspace.config import WorkspaceConfig
+
+ ws_config = target.ws_config or WorkspaceConfig.load(target.ws_root)
+ resolved = repo_path.resolve()
+ alias = next(
+ (e.alias for e in ws_config.repos if (target.ws_root / e.path).resolve() == resolved),
+ None,
+ )
+ if alias is None:
+ return None, None
+ from repowise.server.mcp_server._enrichment import CrossRepoEnricher
+
+ return CrossRepoEnricher.for_workspace(target.ws_root), alias
+
+
+def _with_cut(served: ServedFinding) -> DeadCodeFindingData:
+ if served.cross_repo_note is None:
+ return served.row
+ return replace(
+ served.row,
+ confidence=served.confidence,
+ safe_to_delete=is_safe(served),
+ evidence=[*served.row.evidence, served.cross_repo_note],
+ )
+
+
+def _cut_cross_repo(
+ report: DeadCodeReport, lookup: CrossRepoLookup | None, alias: str | None, floor: float
+) -> tuple[DeadCodeReport, int]:
+ """The cross-repo cut every surface applies, then the floor again, since it only lowers.
+
+ Returns the report and how many findings the cut touched.
+ """
+ if lookup is None:
+ return report, 0
+ served = serve_findings(report.findings, lookup, alias)
+ cut = [_with_cut(s) for s in served]
+ shown = [f for f in cut if f.confidence >= floor]
+ touched = sum(1 for s in served if s.cross_repo_note)
+ return DeadCodeReport.from_findings(
+ shown, hidden_below_threshold=report.hidden_below_threshold + len(cut) - len(shown)
+ ), touched
+
+
@click.command("dead-code")
@click.argument("path", required=False, type=click.Path(exists=True))
@click.option(
@@ -238,8 +295,9 @@ def dead_code_command(
with no index, it parses the working tree and analyzes it live.
In workspace mode, analyzes the primary repo by default; pass
- --repo <alias> to target a different repo. Cross-repo dead-code
- detection is not yet supported — run once per repo for now.
+ --repo <alias> to target a different repo. A finding whose file another
+ workspace repo may use is never cleanup-ready, with the same confidence as
+ on every other surface. Run once per repo.
"""
# The live path parses the whole tree, and its structlog lines go to
# stdout: they would corrupt JSON/Markdown and bury the table.
@@ -294,6 +352,14 @@ def dead_code_command(
report = _analyze_live(repo_path, config, notices)
else:
_notice_stored(repo_path, notices)
+ report, touched = _cut_cross_repo(
+ report, *_cross_repo_inputs(target, repo_path, no_workspace), min_confidence
+ )
+ if touched:
+ notices.print(
+ f"[dim]{touched} finding(s) not cleanup-ready: another workspace repo may use "
+ "their file.[/dim]"
+ )
findings = sorted(report.findings, key=_finding_order)
if safe_only:
diff --git a/packages/core/src/repowise/core/analysis/dead_code/serving.py b/packages/core/src/repowise/core/analysis/dead_code/serving.py
index 91d978667..20948f611 100644
--- a/packages/core/src/repowise/core/analysis/dead_code/serving.py
+++ b/packages/core/src/repowise/core/analysis/dead_code/serving.py
@@ -9,7 +9,7 @@ from __future__ import annotations
import json
import posixpath
-from collections.abc import Callable
+from collections.abc import Callable, Mapping
from dataclasses import dataclass
from dataclasses import field as dataclass_field
from typing import Any, Protocol
@@ -179,18 +179,16 @@ def apply_filters(findings: list, filters: FindingFilters) -> list:
return [f for f in findings if all(check(f) for check in checks)]
-def summary_counts(
- shown: list, withdrawn: Callable[[Any], bool] | None = None
-) -> dict[str, Any]:
+def summary_counts(shown: list) -> dict[str, Any]:
"""Counts over every shown open finding; merge per-repo parts with
:func:`merge_summary_counts` so no caller holds every repo's rows at once.
- *withdrawn* (see :func:`cross_repo_withdraws`) keeps safe counts in step with the tiers.
+ Pass :func:`serve_findings` rows so safe counts agree with the tiers.
"""
by_kind: dict[str, int] = {}
for f in shown:
kind = field(f, "kind")
by_kind[kind] = by_kind.get(kind, 0) + 1
- safe = [f for f in shown if is_safe(f) and not (withdrawn and withdrawn(f))]
+ safe = [f for f in shown if is_safe(f)]
return {
"total_findings": len(shown),
"deletable_lines": sum(field(f, "lines") or 0 for f in safe),
@@ -332,6 +330,9 @@ def serialize_finding(
label = verification_label(result["kind"])
if label:
result["verification"] = label
+ note = field(f, "cross_repo_note")
+ if note:
+ result["cross_repo_note"] = note
if git_meta_map:
meaningful = last_meaningful_change(git_meta_map.get(result["file_path"]))
if meaningful:
@@ -339,7 +340,8 @@ def serialize_finding(
return result
-def _tier_of(confidence: float) -> str:
+def tier_of(confidence: float) -> str:
+ """The tier *confidence* falls in, by :data:`TIER_FLOORS`."""
if confidence >= TIER_FLOORS["high"]:
return "high"
if confidence >= TIER_FLOORS["medium"]:
@@ -361,7 +363,7 @@ def build_tiers(
"""
banded: dict[str, list[dict]] = {"high": [], "medium": [], "low": []}
for f in findings:
- banded[_tier_of(f["confidence"])].append(f)
+ banded[tier_of(f["confidence"])].append(f)
tiers: dict[str, Any] = {}
for name, items in banded.items():
@@ -449,7 +451,7 @@ def _recommendation(tiers: dict) -> str:
class CrossRepoLookup(Protocol):
- """What :func:`adjust_cross_repo` needs from the workspace's cross-repo data."""
+ """What :func:`serve_findings` needs from the workspace's cross-repo data."""
def has_cross_repo_consumers(self, repo_alias: str, file_path: str) -> list[dict]: ...
@@ -460,77 +462,127 @@ class CrossRepoLookup(Protocol):
def get_contract_links_as_provider(self, repo_alias: str, file_path: str) -> list[dict]: ...
-def cross_repo_withdraws(
- lookup: CrossRepoLookup | None, alias: str | None, file_path: str, kind: Any
-) -> bool:
- """Whether :func:`adjust_cross_repo` would withdraw ``safe_to_delete``."""
- if lookup is None or not alias:
- return False
- if lookup.has_cross_repo_consumers(alias, file_path):
- return True
- return kind == "unused_export" and bool(lookup.get_repos_depending_on(alias))
+@dataclass(frozen=True)
+class CrossRepoCut:
+ """What another repo's use does to a finding: never safe, maybe lower, and why."""
+ factor: float
+ note: str
-def adjust_cross_repo(
- findings: list[dict], lookup: CrossRepoLookup | None, repo_alias: str | None = None
-) -> None:
- """Lower confidence on serialized findings that other repos consume, in place.
- Runs before :func:`build_tiers`, so a lowered finding lands in the tier its
- new confidence belongs to. A finding's own ``repo`` wins over *repo_alias*,
- so one call covers both a single repo and the workspace-wide merge.
+# A contract link names the file another repo calls; co-change and package
+# links only say a consumer may exist, so they withdraw safety and leave the
+# confidence alone. Measured on a three-repo workspace: 7 of 7 findings those
+# weaker links had cut had no consumer in another repo.
+_CONTRACT_FACTOR = 0.3
+
+
+def cross_repo_cut(
+ lookup: CrossRepoLookup | None, alias: str | None, file_path: str, kind: Any
+) -> CrossRepoCut | None:
+ """What another workspace repo's use of *file_path* does to its finding, or None.
+
+ A contract link (HTTP route, generated client) from another repo lowers
+ confidence for every kind. Co-change partners in another repo, or a
+ package dependent of an export's repo, only withdraw ``safe_to_delete``.
"""
- if lookup is None:
- return
- for finding in findings:
- alias = finding.get("repo", repo_alias)
- if alias:
- _adjust_one(finding, lookup, alias)
-
-
-def _adjust_one(finding: dict, lookup: CrossRepoLookup, alias: str) -> None:
- consumers = lookup.has_cross_repo_consumers(alias, finding.get("file_path", ""))
- if consumers:
- finding["confidence"] = round(finding["confidence"] * 0.5, 2)
- finding["safe_to_delete"] = False
- consumer_repos = sorted({c["repo"] for c in consumers})
- finding["cross_repo_note"] = (
- f"Confidence reduced: {len(consumers)} cross-repo consumer(s) "
- f"in {', '.join(consumer_repos)}."
+ if lookup is None or not alias:
+ return None
+ if contract_repos := _contract_consumers(lookup, alias, file_path):
+ noun = "export" if kind == "unused_export" else "file"
+ return CrossRepoCut(
+ _CONTRACT_FACTOR,
+ f"This {noun} may be consumed by: {', '.join(sorted(contract_repos))}. "
+ "Verify before deletion.",
)
- return
- # Package-level dependents may consume an export without a file edge.
- if finding.get("kind") != "unused_export":
- return
- if lookup.get_repos_depending_on(alias):
- finding["confidence"] = round(finding["confidence"] * 0.3, 2)
- finding["safe_to_delete"] = False
- finding["cross_repo_note"] = _package_dependent_note(
- lookup, alias, finding.get("file_path", "")
+ if partners := lookup.has_cross_repo_consumers(alias, file_path):
+ repos = sorted({c["repo"] for c in partners})
+ return CrossRepoCut(
+ 1.0,
+ f"Not cleanup-ready: changes together with {len(partners)} file(s) in "
+ f"{', '.join(repos)}. Verify before deletion.",
)
+ if kind == "unused_export" and lookup.get_repos_depending_on(alias):
+ return CrossRepoCut(1.0, _package_dependent_note(lookup, alias, file_path))
+ return None
-def _package_dependent_note(lookup: CrossRepoLookup, alias: str, file_path: str) -> str:
- """Name only the dependents whose recorded link reaches *file_path*.
+class ServedFinding:
+ """A stored finding as every surface shows it: the cross-repo cut applied.
- The cut itself stays repo-wide: package links miss consumers (an
- unresolved PyPI pin, a CLI call), so they can name a consumer but never
- prove there is none.
+ Reads through to the row for every other field, so filters, serializers
+ and response models take it wherever they take the row.
"""
- reaching = {
+
+ __slots__ = ("confidence", "cross_repo_note", "row", "safe_to_delete")
+
+ def __init__(self, row: Any, cut: CrossRepoCut | None) -> None:
+ self.row = row
+ self.confidence = field(row, "confidence")
+ self.safe_to_delete = field(row, "safe_to_delete")
+ self.cross_repo_note = None
+ if cut is not None:
+ if cut.factor != 1.0:
+ self.confidence = round(self.confidence * cut.factor, 2)
+ self.safe_to_delete = False
+ self.cross_repo_note = cut.note
+
+ def __getattr__(self, name: str) -> Any:
+ row = object.__getattribute__(self, "row")
+ if isinstance(row, Mapping):
+ try:
+ return row[name]
+ except KeyError:
+ raise AttributeError(name) from None
+ return getattr(row, name)
+
+
+def serve_findings(
+ rows: list,
+ lookup: CrossRepoLookup | None,
+ alias: str | None,
+ filters: FindingFilters | None = None,
+) -> list[ServedFinding]:
+ """The one read every surface serves findings through.
+
+ The cross-repo cut runs first, so the confidence floor, ``safe_only`` and
+ the tiers all see the confidence the finding is shown with (#4196).
+ """
+ served = [
+ ServedFinding(r, cross_repo_cut(lookup, alias, field(r, "file_path"), field(r, "kind")))
+ for r in rows
+ ]
+ return apply_filters(served, filters) if filters is not None else served
+
+
+def _contract_consumers(lookup: CrossRepoLookup, alias: str, file_path: str) -> set[str]:
+ """The other repos a recorded contract link from *file_path* reaches."""
+ return {
link["consumer_repo"]
for link in lookup.get_contract_links_as_provider(alias, file_path)
if link.get("consumer_repo") not in (None, alias)
}
- reaching.update(
+
+
+def _package_dependent_note(lookup: CrossRepoLookup, alias: str, file_path: str) -> str:
+ """Name only the dependents whose package link reaches *file_path*.
+
+ Safety is withdrawn either way: package links miss consumers (an
+ unresolved PyPI pin, a CLI call), so they can name a consumer but never
+ prove there is none.
+ """
+ reaching = {
link["source_repo"]
for link in lookup.get_package_consumers(alias)
if _inside_manifest(file_path, link.get("target_manifest"))
- )
+ }
if reaching:
- return f"This export may be consumed by: {', '.join(sorted(reaching))}. Verify before deletion."
+ return (
+ f"Not cleanup-ready: {', '.join(sorted(reaching))} may consume this export. "
+ "Verify before deletion."
+ )
return (
- "Confidence lowered: another workspace repo depends on this one, though no recorded "
+ "Not cleanup-ready: another workspace repo depends on this one, though no recorded "
"package or contract link reaches this file. Verify before deletion."
)
diff --git a/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py b/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py
index 90f0f4593..f59463419 100644
--- a/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py
+++ b/packages/core/src/repowise/core/persistence/crud/analysis/dead_code.py
@@ -11,10 +11,12 @@ from sqlalchemy.ext.asyncio import AsyncSession
from repowise.core.analysis.dead_code.deletion_gate import effective_safe_to_delete
from repowise.core.analysis.dead_code.models import DeadCodeFindingData, DeadCodeKind
-from repowise.core.analysis.dead_code.risk_factors import (
- RISK_CAP_CONFIDENCE,
- SAFE_CONFIDENCE_THRESHOLD,
- path_risk_factors,
+from repowise.core.analysis.dead_code.risk_factors import path_risk_factors
+from repowise.core.analysis.dead_code.serving import (
+ CrossRepoLookup,
+ is_safe,
+ serve_findings,
+ tier_of,
)
from repowise.core.analysis.finding_registry import excluded_types
@@ -306,11 +308,18 @@ async def update_dead_code_status(
async def get_dead_code_summary(
- session: AsyncSession, repository_id: str, *, include_unverified: bool = False
+ session: AsyncSession,
+ repository_id: str,
+ *,
+ include_unverified: bool = False,
+ lookup: CrossRepoLookup | None = None,
+ alias: str | None = None,
) -> dict:
"""Return aggregate dead code statistics over the findings a surface shows.
``gated`` counts the open findings a language gate held back, by language.
+ In a workspace, *lookup* and *alias* apply the cross-repo cut first, so the
+ counts match the list (:func:`serve_findings`).
"""
scope = (
DeadCodeFinding.repository_id == repository_id,
@@ -328,7 +337,7 @@ async def get_dead_code_summary(
),
)
)
- findings = list(result.scalars().all())
+ findings = serve_findings(list(result.scalars().all()), lookup, alias)
gated = await gated_counts(
session,
"dead_code",
@@ -343,12 +352,7 @@ async def get_dead_code_summary(
by_kind: dict[str, int] = {}
for f in findings:
- if f.confidence >= SAFE_CONFIDENCE_THRESHOLD:
- summary["high"] += 1
- elif f.confidence >= RISK_CAP_CONFIDENCE:
- summary["medium"] += 1
- else:
- summary["low"] += 1
+ summary[tier_of(f.confidence)] += 1
total_lines += f.lines or 0
by_kind[f.kind] = by_kind.get(f.kind, 0) + 1
@@ -357,11 +361,7 @@ async def get_dead_code_summary(
# risk-factor logic existed (or in a config/bootstrap/database/environment
# file the allowlist missed) are not counted as deletion-ready.
# Totals sum the known counts; an unknown (NULL) count adds nothing.
- deletable = [
- f
- for f in findings
- if effective_safe_to_delete(f.confidence, f.file_path, f.safe_to_delete, f.kind)
- ]
+ deletable = [f for f in findings if is_safe(f)]
deletable_lines = sum(f.lines or 0 for f in deletable)
return {
diff --git a/packages/server/src/repowise/server/deps.py b/packages/server/src/repowise/server/deps.py
index 96ea189ec..1039abd51 100644
--- a/packages/server/src/repowise/server/deps.py
+++ b/packages/server/src/repowise/server/deps.py
@@ -13,6 +13,7 @@ import ipaddress
import logging
import os
from collections.abc import AsyncGenerator
+from pathlib import Path
from fastapi import HTTPException, Request, Security
from fastapi.security import APIKeyHeader, SecurityScopes
@@ -104,6 +105,19 @@ async def get_cross_repo_enricher(request: Request):
return getattr(request.app.state, "cross_repo_enricher", None)
+def workspace_alias_for(app_state, repo_id: str) -> str | None:
+ """The workspace alias of the member stored as ``repo_id``; None outside a workspace."""
+ ws_config = getattr(app_state, "workspace_config", None)
+ ws_root = getattr(app_state, "workspace_root", None)
+ path_to_id = getattr(app_state, "workspace_path_to_repo_id", None) or {}
+ if ws_config is None or ws_root is None:
+ return None
+ for entry in ws_config.repos:
+ if path_to_id.get(str((Path(ws_root) / entry.path).resolve())) == repo_id:
+ return entry.alias
+ return None
+
+
def client_is_local(request: Request) -> bool:
"""True when the request's peer address is a loopback address.
diff --git a/packages/server/src/repowise/server/mcp_server/_enrichment.py b/packages/server/src/repowise/server/mcp_server/_enrichment.py
index bf225135b..fa395e7ae 100644
--- a/packages/server/src/repowise/server/mcp_server/_enrichment.py
+++ b/packages/server/src/repowise/server/mcp_server/_enrichment.py
@@ -133,6 +133,24 @@ class CrossRepoEnricher:
# update. Read-only.
self._conformance: dict | None = None
+ @classmethod
+ def for_workspace(cls, ws_root: Path) -> CrossRepoEnricher:
+ """The enricher over every artifact a workspace update wrote under *ws_root*."""
+ from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME
+ from repowise.core.workspace.config import WORKSPACE_DATA_DIR
+ from repowise.core.workspace.conformance import CONFORMANCE_FILENAME
+ from repowise.core.workspace.contracts import CONTRACTS_FILENAME
+ from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME
+
+ data_dir = Path(ws_root) / WORKSPACE_DATA_DIR
+ return cls(
+ data_dir / "cross_repo_edges.json",
+ contracts_path=data_dir / CONTRACTS_FILENAME,
+ system_graph_path=data_dir / SYSTEM_GRAPH_FILENAME,
+ breaking_changes_path=data_dir / BREAKING_CHANGES_FILENAME,
+ conformance_path=data_dir / CONFORMANCE_FILENAME,
+ )
+
@classmethod
def from_data(
cls,
diff --git a/packages/server/src/repowise/server/mcp_server/_server.py b/packages/server/src/repowise/server/mcp_server/_server.py
index 47af2e4cd..0777ab783 100644
--- a/packages/server/src/repowise/server/mcp_server/_server.py
+++ b/packages/server/src/repowise/server/mcp_server/_server.py
@@ -483,26 +483,10 @@ async def _lifespan(server: FastMCP):
# Load cross-repo enricher (Phase 3 + 4)
try:
- from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME
- from repowise.core.workspace.config import WORKSPACE_DATA_DIR
- from repowise.core.workspace.conformance import CONFORMANCE_FILENAME
- from repowise.core.workspace.contracts import CONTRACTS_FILENAME
- from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME
from repowise.server.mcp_server._enrichment import CrossRepoEnricher
- cross_repo_path = ws_root / WORKSPACE_DATA_DIR / "cross_repo_edges.json"
- contracts_path = ws_root / WORKSPACE_DATA_DIR / CONTRACTS_FILENAME
- system_graph_path = ws_root / WORKSPACE_DATA_DIR / SYSTEM_GRAPH_FILENAME
- breaking_changes_path = ws_root / WORKSPACE_DATA_DIR / BREAKING_CHANGES_FILENAME
- conformance_path = ws_root / WORKSPACE_DATA_DIR / CONFORMANCE_FILENAME
- enricher = CrossRepoEnricher(
- cross_repo_path,
- contracts_path=contracts_path,
- system_graph_path=system_graph_path,
- breaking_changes_path=breaking_changes_path,
- conformance_path=conformance_path,
- )
- if enricher.has_data or enricher.has_system_graph:
+ enricher = CrossRepoEnricher.for_workspace(ws_root)
+ if enricher.has_data or enricher.has_contract_data or enricher.has_system_graph:
_state._cross_repo_enricher = enricher
_log.info(
"Cross-repo enricher loaded: %d co-change edges, %d package deps, %d contract links",
diff --git a/packages/server/src/repowise/server/mcp_server/tool_dead_code.py b/packages/server/src/repowise/server/mcp_server/tool_dead_code.py
index 883ca399b..244e75295 100644
--- a/packages/server/src/repowise/server/mcp_server/tool_dead_code.py
+++ b/packages/server/src/repowise/server/mcp_server/tool_dead_code.py
@@ -14,22 +14,20 @@ from repowise.core.analysis.dead_code.serving import (
TIER_FLOORS,
CrossRepoLookup,
FindingFilters,
- adjust_cross_repo,
apply_filters,
build_summary,
build_tiers,
compute_impact,
- cross_repo_withdraws,
dead_code_finding_id,
excluded_kinds,
merge_summary_counts,
rollup_by_directory,
rollup_by_owner,
serialize_finding,
+ serve_findings,
summary_counts,
)
from repowise.core.analysis.finding_registry import excluded_types, served_previews
-from repowise.core.analysis.health.rows import field
from repowise.core.persistence.crud import get_dead_code_findings
from repowise.core.persistence.database import get_session
from repowise.core.persistence.models import GitMetadata
@@ -52,29 +50,8 @@ from repowise.server.mcp_server._meta import build_meta as _build_meta
def _cross_repo_lookup() -> CrossRepoLookup | None:
- """The workspace's cross-repo data, when there is any to adjust by."""
- enricher = _state._cross_repo_enricher
- if enricher is None or not enricher.has_data or not _is_workspace_mode():
- return None
- return enricher
-
-
-def _adjust_cross_repo(
- findings: list[dict], filters: FindingFilters, repo_alias: str | None
-) -> list[dict]:
- """The cross-repo cut, then ``safe_only`` again, since the cut withdraws safety."""
- adjust_cross_repo(findings, _cross_repo_lookup(), repo_alias)
- if filters.safe_only:
- return [f for f in findings if f["safe_to_delete"]]
- return findings
-
-
-def _withdrawn_by(repo_alias: str | None) -> Callable[[Any], bool] | None:
- """The cross-repo cut as a predicate over stored rows, for the summary."""
- lookup = _cross_repo_lookup()
- if lookup is None or not repo_alias:
- return None
- return lambda f: cross_repo_withdraws(lookup, repo_alias, field(f, "file_path"), field(f, "kind"))
+ """The workspace's cross-repo data; an empty artifact simply cuts nothing."""
+ return _state._cross_repo_enricher if _is_workspace_mode() else None
async def _get_dead_code_all_repos(
@@ -96,11 +73,12 @@ async def _get_dead_code_all_repos(
repo_findings, withheld = filters.split_withheld(repo_findings)
repo_findings, gated = filters.split_gated(repo_findings)
git_meta_map = await _load_git_meta_map(session, repository.id, repo_findings)
+ served = serve_findings(repo_findings, _cross_repo_lookup(), ctx.alias)
serialized = [
serialize_finding(f, git_meta_map, repository=ctx.alias)
- for f in apply_filters(repo_findings, filters)
+ for f in apply_filters(served, filters)
]
- return serialized, summary_counts(repo_findings, _withdrawn_by(ctx.alias)), withheld, gated
+ return serialized, summary_counts(served), withheld, gated
fed = Federation()
answered = await fed.run(_one_repo)
@@ -113,7 +91,6 @@ async def _get_dead_code_all_repos(
merged = into.setdefault(name, {**entry, "count": 0})
merged["count"] += entry["count"]
- merged_findings = _adjust_cross_repo(merged_findings, filters, None)
summary = build_summary(
merge_summary_counts([part[1] for _, part in answered]),
len(merged_findings),
@@ -198,7 +175,7 @@ async def get_dead_code(
Run before a cleanup sprint, not a targeted fix. Findings tier
high/medium/low with per-directory and per-owner rollups; workspace
- mode lowers confidence on findings other repos import.
+ mode withdraws safety on findings other repos may use.
Args:
repo: usually omitted.
@@ -317,11 +294,12 @@ async def get_dead_code(
git_meta_map = await _load_git_meta_map(session, repository.id, every_shown_kind)
reference_repository = ctx.alias or repository.name
+ lookup = _cross_repo_lookup()
if finding_id:
match = next(
(
row
- for row in every_shown_kind
+ for row in serve_findings(every_shown_kind, lookup, ctx.alias)
if finding_id in {row.id, dead_code_finding_id(row, reference_repository)}
),
None,
@@ -345,7 +323,8 @@ async def get_dead_code(
),
}
- filtered = apply_filters(all_findings, filters)
+ served = serve_findings(all_findings, lookup, ctx.alias)
+ filtered = apply_filters(served, filters)
serialized = [
serialize_finding(f, git_meta_map, repository=reference_repository) for f in filtered
]
@@ -356,9 +335,8 @@ async def get_dead_code(
"\n".join(json.dumps(f, separators=(",", ":")) for f in beyond),
)
- serialized = _adjust_cross_repo(serialized, filters, ctx.alias)
tiers = build_tiers(serialized, limit, tier, on_overflow=_keep_overflow)
- counts = summary_counts(all_findings, _withdrawn_by(ctx.alias))
+ counts = summary_counts(served)
summary = build_summary(counts, len(serialized), filters, withheld, gated)
result: dict[str, Any] = {"summary": summary, "tiers": tiers}
diff --git a/packages/server/src/repowise/server/routers/dead_code.py b/packages/server/src/repowise/server/routers/dead_code.py
index bdf64b1ef..9218cd239 100644
--- a/packages/server/src/repowise/server/routers/dead_code.py
+++ b/packages/server/src/repowise/server/routers/dead_code.py
@@ -5,12 +5,12 @@ from __future__ import annotations
from fastapi import APIRouter, Depends, HTTPException, Query, Request
from sqlalchemy.ext.asyncio import AsyncSession
-from repowise.core.analysis.dead_code.deletion_gate import effective_safe_to_delete
from repowise.core.analysis.dead_code.risk_factors import (
RISK_CAP_CONFIDENCE,
)
+from repowise.core.analysis.dead_code.serving import FindingFilters, ServedFinding, serve_findings
from repowise.core.persistence import crud
-from repowise.server.deps import get_db_session, verify_api_key
+from repowise.server.deps import get_db_session, verify_api_key, workspace_alias_for
from repowise.server.routers._unverified import UnverifiedQuery
from repowise.server.schemas import (
DeadCodeAnalyzeResponse,
@@ -26,12 +26,30 @@ router = APIRouter(
)
+def _cross_repo(request: Request, repo_id: str) -> dict:
+ """The cross-repo cut's inputs for *repo_id*; empty outside a workspace."""
+ state = request.app.state
+ return {
+ "lookup": getattr(state, "cross_repo_enricher", None),
+ "alias": workspace_alias_for(state, repo_id),
+ }
+
+
+def _response(f: ServedFinding) -> DeadCodeFindingResponse:
+ response = DeadCodeFindingResponse.from_orm(f)
+ if f.cross_repo_note:
+ # Evidence is the list the finding's signals already render from.
+ response.evidence.append(f.cross_repo_note)
+ return response
+
+
@router.get(
"/api/repos/{repo_id}/dead-code",
response_model=list[DeadCodeFindingResponse],
)
async def list_dead_code(
repo_id: str,
+ request: Request,
kind: str | None = Query(None, description="Filter by finding kind"),
min_confidence: float = Query(RISK_CAP_CONFIDENCE, ge=0.0, le=1.0),
status: str = Query("open"),
@@ -41,7 +59,8 @@ async def list_dead_code(
session: AsyncSession = Depends(get_db_session),
) -> list[DeadCodeFindingResponse]:
"""List dead code findings for a repository."""
- findings = await crud.get_dead_code_findings(
+ # The cut only lowers confidence, so the SQL floor keeps a superset.
+ rows = await crud.get_dead_code_findings(
session,
repo_id,
kind=kind,
@@ -49,13 +68,12 @@ async def list_dead_code(
status=status,
include_unverified=include_unverified,
)
- if safe_only:
- findings = [
- f
- for f in findings
- if effective_safe_to_delete(f.confidence, f.file_path, f.safe_to_delete, f.kind)
- ]
- return [DeadCodeFindingResponse.from_orm(f) for f in findings[:limit]]
+ filters = FindingFilters(
+ kind=None, safe_only=safe_only, min_confidence=min_confidence, directory=None, owner=None
+ )
+ findings = serve_findings(rows, **_cross_repo(request, repo_id), filters=filters)
+ findings.sort(key=lambda f: -f.confidence)
+ return [_response(f) for f in findings[:limit]]
@router.post(
@@ -112,12 +130,13 @@ async def analyze_dead_code(
)
async def dead_code_summary(
repo_id: str,
+ request: Request,
include_unverified: bool = UnverifiedQuery,
session: AsyncSession = Depends(get_db_session),
) -> DeadCodeSummaryResponse:
"""Get aggregate dead code statistics for a repository."""
summary = await crud.get_dead_code_summary(
- session, repo_id, include_unverified=include_unverified
+ session, repo_id, include_unverified=include_unverified, **_cross_repo(request, repo_id)
)
analyzed_at = await dead_code_analyzed_at(session, repo_id)
return DeadCodeSummaryResponse(**summary, analyzed_at=analyzed_at)
@@ -127,6 +146,7 @@ async def dead_code_summary(
async def resolve_finding(
finding_id: str,
body: DeadCodePatchRequest,
+ request: Request,
session: AsyncSession = Depends(get_db_session),
) -> DeadCodeFindingResponse:
"""Update the status of a dead code finding."""
@@ -140,4 +160,5 @@ async def resolve_finding(
finding = await crud.update_dead_code_status(session, finding_id, body.status, body.note)
if finding is None:
raise HTTPException(status_code=404, detail="Finding not found")
- return DeadCodeFindingResponse.from_orm(finding)
+ repo_id = finding.repository_id
+ return _response(serve_findings([finding], **_cross_repo(request, repo_id))[0])
diff --git a/packages/server/src/repowise/server/workspace_startup.py b/packages/server/src/repowise/server/workspace_startup.py
index bec55af38..3863dda09 100644
--- a/packages/server/src/repowise/server/workspace_startup.py
+++ b/packages/server/src/repowise/server/workspace_startup.py
@@ -195,22 +195,10 @@ async def _reset_member_stale_jobs(app_state) -> None:
def _publish_cross_repo_enricher(app_state, ws_config, ws_root: Path) -> None:
- from repowise.core.workspace.breaking_change import BREAKING_CHANGES_FILENAME
- from repowise.core.workspace.config import WORKSPACE_DATA_DIR
- from repowise.core.workspace.conformance import CONFORMANCE_FILENAME
- from repowise.core.workspace.contracts import CONTRACTS_FILENAME
- from repowise.core.workspace.system_graph import SYSTEM_GRAPH_FILENAME
from repowise.server.chat_tools import set_tool_workspace
from repowise.server.mcp_server._enrichment import CrossRepoEnricher
- data_dir = ws_root / WORKSPACE_DATA_DIR
- enricher = CrossRepoEnricher(
- data_dir / "cross_repo_edges.json",
- contracts_path=data_dir / CONTRACTS_FILENAME,
- system_graph_path=data_dir / SYSTEM_GRAPH_FILENAME,
- breaking_changes_path=data_dir / BREAKING_CHANGES_FILENAME,
- conformance_path=data_dir / CONFORMANCE_FILENAME,
- )
+ enricher = CrossRepoEnricher.for_workspace(ws_root)
if enricher.has_data or enricher.has_contract_data or enricher.has_system_graph:
app_state.cross_repo_enricher = enricher
set_tool_workspace(cross_repo_enricher=enricher)
diff --git a/tests/unit/cli/test_dead_code_stored.py b/tests/unit/cli/test_dead_code_stored.py
index 02cdbfb89..dec33c2fd 100644
--- a/tests/unit/cli/test_dead_code_stored.py
+++ b/tests/unit/cli/test_dead_code_stored.py
@@ -206,3 +206,47 @@ def test_footer_names_the_tier_counts_as_findings(indexed_repo, monkeypatch):
assert "Cleanup-candidate lines:" in result.output
assert "findings by confidence: high 1" in result.output
assert "confidence)" not in result.output
+
+
+class _HttpConsumed:
+ def has_cross_repo_consumers(self, repo_alias, file_path):
+ return []
+
+ def get_repos_depending_on(self, repo_alias):
+ return []
+
+ def get_package_consumers(self, repo_alias):
+ return []
+
+ def get_contract_links_as_provider(self, repo_alias, file_path):
+ return [{"consumer_repo": "web"}]
+
+
+def test_a_workspace_consumer_lowers_the_stored_finding(indexed_repo, monkeypatch):
+ analyze_live = dead_code_cmd._analyze_live
+ monkeypatch.setattr(dead_code_cmd, "_analyze_live", None)
+ monkeypatch.setattr(
+ dead_code_cmd, "_cross_repo_inputs", lambda *_a: (_HttpConsumed(), "api")
+ )
+ # 0.9 * 0.3 = 0.27, under the default floor the other surfaces apply too.
+ assert _json(indexed_repo) == []
+ assert "1 finding(s) hidden below threshold" in _md(indexed_repo)
+ # The live path takes the same cut.
+ monkeypatch.setattr(dead_code_cmd, "_analyze_live", analyze_live)
+ live = _json(indexed_repo, "--min-confidence", "0.0")
+ assert live and all(f["confidence"] <= 0.3 and not f["safe_to_delete"] for f in live)
+
+
+def test_cross_repo_inputs_resolve_the_alias_and_honour_no_workspace(tmp_path, monkeypatch):
+ from types import SimpleNamespace
+
+ from repowise.server.mcp_server._enrichment import CrossRepoEnricher
+
+ monkeypatch.setattr(CrossRepoEnricher, "for_workspace", classmethod(lambda cls, root: root))
+ member = tmp_path / "api"
+ target = SimpleNamespace(
+ ws_root=tmp_path, ws_config=SimpleNamespace(repos=[SimpleNamespace(alias="api", path="api")])
+ )
+ assert dead_code_cmd._cross_repo_inputs(target, member, False) == (tmp_path, "api")
+ assert dead_code_cmd._cross_repo_inputs(target, member, True) == (None, None)
+ assert dead_code_cmd._cross_repo_inputs(target, tmp_path / "other", False) == (None, None)
diff --git a/tests/unit/dead_code/test_serving.py b/tests/unit/dead_code/test_serving.py
index 43bd67d3c..7781178e5 100644
--- a/tests/unit/dead_code/test_serving.py
+++ b/tests/unit/dead_code/test_serving.py
@@ -15,20 +15,21 @@ from repowise.core.analysis.dead_code.serving import (
SUMMARY_SCOPE,
TIER_FLOORS,
FindingFilters,
- adjust_cross_repo,
apply_filters,
build_summary,
build_tiers,
compute_impact,
- cross_repo_withdraws,
+ cross_repo_cut,
dead_code_finding_id,
excluded_kinds,
+ is_safe,
last_meaningful_change,
merge_summary_counts,
rollup_by_directory,
rollup_by_owner,
safe_only_note,
serialize_finding,
+ serve_findings,
summary_counts,
)
@@ -243,34 +244,64 @@ class _Lookup:
return [{"consumer_repo": "web"}] if file_path == "src/a/two.py" else []
-def test_adjust_cross_repo_lowers_consumed_findings() -> None:
- findings = [serialize_finding(r) for r in _ROWS]
- adjust_cross_repo(findings, _Lookup(), "api")
- by_path = {f["file_path"]: f for f in findings}
- assert by_path["src/a/one.py"]["confidence"] == 0.45
- assert "1 cross-repo consumer(s) in web" in by_path["src/a/one.py"]["cross_repo_note"]
- assert by_path["src/b/five.py"]["confidence"] == 0.27
- assert "mobile" in by_path["src/b/five.py"]["cross_repo_note"]
+def _served(rows: list, lookup=None, alias: str | None = "api") -> list[dict]:
+ return [serialize_finding(f) for f in serve_findings(rows, lookup or _Lookup(), alias)]
+
+
+def test_only_a_contract_link_lowers_confidence() -> None:
+ by_path = {f["file_path"]: f for f in _served(_ROWS)}
+ # Contract provider: cut to 30%, the consumer named.
+ assert by_path["src/a/two.py"]["confidence"] == 0.28
+ assert "consumed by: web." in by_path["src/a/two.py"]["cross_repo_note"]
+ # Co-change partners and package dependents keep the confidence.
+ assert by_path["src/a/one.py"]["confidence"] == 0.9
+ assert "changes together with 1 file(s) in web" in by_path["src/a/one.py"]["cross_repo_note"]
+ assert by_path["src/b/five.py"]["confidence"] == 0.9
+ assert "mobile may consume this export." in by_path["src/b/five.py"]["cross_repo_note"]
# A finding another repo may consume is never safe to delete.
- assert not by_path["src/a/one.py"]["safe_to_delete"]
- assert not by_path["src/b/five.py"]["safe_to_delete"]
+ assert not any(f["safe_to_delete"] for f in by_path.values())
def test_package_dependents_are_named_only_where_their_link_reaches() -> None:
- findings = [serialize_finding(r) for r in _ROWS]
- adjust_cross_repo(findings, _Lookup(), "api")
- by_path = {f["file_path"]: f for f in findings}
- # Inside the consumed package, and a contract provider: named.
- assert "consumed by: mobile." in by_path["src/b/five.py"]["cross_repo_note"]
- assert "consumed by: web." in by_path["src/a/two.py"]["cross_repo_note"]
- # Outside every link: nobody is named, yet the cut stays and safety is withdrawn.
- lone = [serialize_finding(_row("src/c/six.py", 0.9))]
- adjust_cross_repo(lone, _Lookup(), "api")
+ # Outside every link: nobody is named, yet safety is withdrawn.
+ lone = _served([_row("src/c/six.py", 0.9)])
assert "mobile" not in lone[0]["cross_repo_note"]
- assert lone[0]["confidence"] == 0.27
+ assert lone[0]["confidence"] == 0.9
assert not lone[0]["safe_to_delete"]
+class _ContractOnlyLookup(_Lookup):
+ """A provider repo nothing depends on as a package, e.g. an HTTP backend."""
+
+ def get_repos_depending_on(self, repo_alias: str) -> list[str]:
+ return []
+
+ def get_package_consumers(self, repo_alias: str) -> list[dict]:
+ return []
+
+
+def test_a_contract_link_cuts_every_kind_without_package_dependents() -> None:
+ rows = [
+ _row("src/a/two.py", 0.9, kind="unreachable_file"),
+ _row("src/a/two.py", 0.95),
+ _row("src/c/six.py", 0.9, kind="unreachable_file"),
+ ]
+ file_row, export_row, untouched = _served(rows, _ContractOnlyLookup())
+ assert file_row["confidence"] == 0.27
+ assert file_row["cross_repo_note"].startswith("This file may be consumed by: web.")
+ assert export_row["cross_repo_note"].startswith("This export may be consumed by: web.")
+ assert not file_row["safe_to_delete"] and not export_row["safe_to_delete"]
+ assert untouched["confidence"] == 0.9 and "cross_repo_note" not in untouched
+
+
+def test_a_same_repo_contract_link_is_not_a_cross_repo_consumer() -> None:
+ class _SelfLinked(_ContractOnlyLookup):
+ def get_contract_links_as_provider(self, repo_alias: str, file_path: str) -> list[dict]:
+ return [{"consumer_repo": repo_alias}]
+
+ assert cross_repo_cut(_SelfLinked(), "api", "src/a/two.py", "unreachable_file") is None
+
+
class _UnscopedLookup(_Lookup):
def get_package_consumers(self, repo_alias: str) -> list[dict]:
return [{"source_repo": "mobile", "target_manifest": ""}]
@@ -278,27 +309,30 @@ class _UnscopedLookup(_Lookup):
def test_a_package_link_with_no_manifest_names_its_dependent() -> None:
# Unknown package scope is not evidence the file sits outside it.
- lone = [serialize_finding(_row("src/c/six.py", 0.9))]
- adjust_cross_repo(lone, _UnscopedLookup(), "api")
- assert "consumed by: mobile." in lone[0]["cross_repo_note"]
+ lone = _served([_row("src/c/six.py", 0.9)], _UnscopedLookup())
+ assert "mobile may consume this export." in lone[0]["cross_repo_note"]
-def test_adjusted_findings_are_tiered_by_their_lowered_confidence() -> None:
- findings = [serialize_finding(r) for r in _ROWS]
- adjust_cross_repo(findings, _Lookup(), "api")
- tiers = build_tiers(findings, 25, None)
+def test_cut_findings_are_tiered_by_their_lowered_confidence() -> None:
+ tiers = build_tiers(_served(_ROWS), 25, None)
for name, block in tiers.items():
for f in block["findings"]:
assert f["confidence"] >= TIER_FLOORS[name]
- assert "src/a/one.py" not in {f["file_path"] for f in tiers["high"]["findings"]}
+ assert "src/a/two.py" in {f["file_path"] for f in tiers["low"]["findings"]}
+
+def test_the_floor_and_safe_only_read_the_cut_confidence() -> None:
+ # 0.95 * 0.3 = 0.28: below the default floor once cut, so not listed.
+ kept = serve_findings(_ROWS, _Lookup(), "api", _filters(min_confidence=RISK_CAP_CONFIDENCE))
+ assert all(f.confidence >= RISK_CAP_CONFIDENCE for f in kept)
+ assert "src/a/two.py" not in {f.file_path for f in kept}
+ assert serve_findings(_ROWS, _Lookup(), "api", _filters(safe_only=True)) == []
-def test_adjust_cross_repo_without_data_or_alias_is_a_no_op() -> None:
- findings = [serialize_finding(r) for r in _ROWS]
- before = json.dumps(findings, default=str)
- adjust_cross_repo(findings, None, "api")
- adjust_cross_repo(findings, _Lookup(), None)
- assert json.dumps(findings, default=str) == before
+
+def test_serve_findings_without_data_or_alias_changes_nothing() -> None:
+ plain = [serialize_finding(r) for r in _ROWS]
+ assert _served(_ROWS, lookup=None, alias=None) == plain
+ assert [serialize_finding(f) for f in serve_findings(_ROWS, None, "api")] == plain
def test_recommendation_never_points_at_an_empty_tier() -> None:
@@ -321,17 +355,16 @@ def test_merged_per_repo_counts_equal_counting_everything_at_once() -> None:
def test_summary_safe_counts_drop_what_the_cross_repo_cut_withdraws() -> None:
- lookup = _Lookup()
-
- def withdrawn(f) -> bool:
- return cross_repo_withdraws(lookup, "api", f["file_path"], f["kind"])
-
plain = summary_counts(_ROWS)
- cut = summary_counts(_ROWS, withdrawn)
- adjusted = [serialize_finding(r) for r in _ROWS]
- adjust_cross_repo(adjusted, lookup, "api")
- assert cut["safe_to_delete_count"] == sum(f["safe_to_delete"] for f in adjusted)
+ served = serve_findings(_ROWS, _Lookup(), "api")
+ cut = summary_counts(served)
+ assert cut["safe_to_delete_count"] == sum(f["safe_to_delete"] for f in _served(_ROWS))
assert cut["safe_to_delete_count"] <= plain["safe_to_delete_count"]
assert cut["total_findings"] == plain["total_findings"]
- assert not cross_repo_withdraws(None, "api", "src/a/one.py", "unused_export")
- assert not cross_repo_withdraws(lookup, None, "src/a/one.py", "unused_export")
+
+
+def test_the_cut_never_makes_a_finding_safe() -> None:
+ rows = [*_ROWS, _row("src/a/one.py", 0.9, safe_to_delete=False)]
+ for served in serve_findings(rows, _Lookup(), "api"):
+ assert served.confidence <= served.row["confidence"]
+ assert not is_safe(served) or is_safe(served.row)
diff --git a/tests/unit/persistence/test_dead_code_crud.py b/tests/unit/persistence/test_dead_code_crud.py
index d38a48c18..60623480d 100644
--- a/tests/unit/persistence/test_dead_code_crud.py
+++ b/tests/unit/persistence/test_dead_code_crud.py
@@ -354,10 +354,12 @@ async def test_get_dead_code_git_fields_is_empty_for_an_unknown_repo(async_sessi
async def test_summary_uses_shared_confidence_thresholds(async_session, monkeypatch):
+ from repowise.core.analysis.dead_code.serving import TIER_FLOORS
from repowise.core.persistence.crud.analysis import dead_code as dead_code_crud
- monkeypatch.setattr(dead_code_crud, "SAFE_CONFIDENCE_THRESHOLD", 0.8)
- monkeypatch.setattr(dead_code_crud, "RISK_CAP_CONFIDENCE", 0.3)
+ # The summary tiers through the serving module's one table.
+ monkeypatch.setitem(TIER_FLOORS, "high", 0.8)
+ monkeypatch.setitem(TIER_FLOORS, "medium", 0.3)
repo = await insert_repo(async_session)
diff --git a/tests/unit/server/mcp/test_dead_code.py b/tests/unit/server/mcp/test_dead_code.py
index 25169e9be..45663c979 100644
--- a/tests/unit/server/mcp/test_dead_code.py
+++ b/tests/unit/server/mcp/test_dead_code.py
@@ -154,3 +154,23 @@ async def test_cross_repo_cut_reaches_summary_and_rollups(setup_mcp, monkeypatch
safe = await get_dead_code(safe_only=True)
assert safe["summary"]["filtered_findings"] == 0
assert "safe_only_note" in safe["summary"]
+
+
+class _EveryFileCalled(_EveryFileConsumed):
+ def get_contract_links_as_provider(self, repo_alias, file_path):
+ return [{"consumer_repo": "web"}]
+
+
+async def test_the_default_floor_reads_the_cut_confidence(setup_mcp, monkeypatch):
+ from repowise.server.mcp_server import get_dead_code, tool_dead_code
+
+ monkeypatch.setattr(tool_dead_code, "_cross_repo_lookup", lambda: _EveryFileCalled())
+
+ # 0.9 / 0.7 / 0.5 cut to 0.27 / 0.21 / 0.15: none clears 0.4.
+ result = await get_dead_code()
+ assert not any(t["findings"] for t in result["tiers"].values())
+ assert result["summary"]["filtered_findings"] == 0
+ assert result["summary"]["total_findings"] == 3
+ low = await get_dead_code(min_confidence="low")
+ assert [f["confidence"] for f in low["tiers"]["low"]["findings"]] == [0.27, 0.21, 0.15]
diff --git a/tests/unit/server/test_dead_code.py b/tests/unit/server/test_dead_code.py
index 7b6464996..335a04a09 100644
--- a/tests/unit/server/test_dead_code.py
+++ b/tests/unit/server/test_dead_code.py
@@ -304,3 +304,78 @@ async def test_stored_safe_unreachable_file_is_review_only_on_every_surface(
async with get_session(app.state.session_factory) as session:
items, total, _ = await _dead_code_items(session, repo["id"])
assert (items, total) == ([], 0)
+
+
+class _ConsumedLookup:
+ """Co-change partners on one file, an HTTP consumer on the other."""
+
+ def has_cross_repo_consumers(self, repo_alias, file_path):
+ return [{"repo": "web"}] if file_path == "src/dead_module.py" else []
+
+ def get_repos_depending_on(self, repo_alias):
+ return []
+
+ def get_package_consumers(self, repo_alias):
+ return []
+
+ def get_contract_links_as_provider(self, repo_alias, file_path):
+ return [{"consumer_repo": "web"}] if file_path == "src/utils.py" else []
+
+
+async def test_workspace_cut_reaches_list_summary_and_patch(
+ client: AsyncClient, app, tmp_path, monkeypatch
+) -> None:
+ from types import SimpleNamespace
+
+ repo = await create_test_repo(client)
+ finding_id = await _insert_dead_code(app.state.session_factory, repo["id"])
+ monkeypatch.setattr(app.state, "cross_repo_enricher", _ConsumedLookup(), raising=False)
+ monkeypatch.setattr(
+ app.state,
+ "workspace_config",
+ SimpleNamespace(repos=[SimpleNamespace(alias="api", path=".")]),
+ raising=False,
+ )
+ monkeypatch.setattr(app.state, "workspace_root", str(tmp_path), raising=False)
+ monkeypatch.setattr(
+ app.state,
+ "workspace_path_to_repo_id",
+ {str(tmp_path.resolve()): repo["id"]},
+ raising=False,
+ )
+
+ # Co-change keeps 0.9 but withdraws safety; 0.5 * 0.3 = 0.15 falls under the floor.
+ listed = (await client.get(f"/api/repos/{repo['id']}/dead-code")).json()
+ assert [(f["file_path"], f["confidence"], f["safe_to_delete"]) for f in listed] == [
+ ("src/dead_module.py", 0.9, False)
+ ]
+ assert any("changes together with" in e for e in listed[0]["evidence"])
+ everything = (
+ await client.get(f"/api/repos/{repo['id']}/dead-code", params={"min_confidence": 0})
+ ).json()
+ assert {f["file_path"]: f["confidence"] for f in everything}["src/utils.py"] == 0.15
+
+ summary = (await client.get(f"/api/repos/{repo['id']}/dead-code/summary")).json()
+ assert summary["confidence_summary"] == {"high": 1, "medium": 0, "low": 1}
+ assert summary["safe_to_delete_count"] == 0
+
+ patched = (
+ await client.patch(f"/api/dead-code/{finding_id}", json={"status": "acknowledged"})
+ ).json()
+ assert patched["confidence"] == 0.9 and patched["safe_to_delete"] is False
+
+
+def test_workspace_alias_for_an_unmapped_repo_is_none(tmp_path) -> None:
+ from types import SimpleNamespace
+
+ from repowise.server.deps import workspace_alias_for
+
+ state = SimpleNamespace(
+ workspace_config=SimpleNamespace(repos=[SimpleNamespace(alias="api", path=".")]),
+ workspace_root=str(tmp_path),
+ workspace_path_to_repo_id={str(tmp_path.resolve()): "r1"},
+ )
+ assert workspace_alias_for(state, "r1") == "api"
+ assert workspace_alias_for(state, "r2") is None
+ assert workspace_alias_for(SimpleNamespace(), "r1") is None