sourcecode 1.32.0__tar.gz → 1.32.2__tar.gz

sourcecode-1.32.2/.continue-here.md

@@ -0,0 +1,106 @@
+# .continue-here.md — sourcecode CLI
+**Session paused:** 2026-05-28  
+**Branch:** master  
+**Last commit:** `7b5011e` fix: 9 correctness bugs — i18n, controller detection, project_type, dep dedup, arch pattern  
+**Version:** 1.32.1
+
+---
+
+## What was done this session
+
+Fixed 9 correctness/reliability bugs identified by user from testing against spring-petclinic and other Spring repos. All committed in `7b5011e`.
+
+| # | Severity | File(s) | Fix |
+|---|----------|---------|-----|
+| 1 | CRITICAL | `architecture_analyzer.py`, `dependency_analyzer.py`, `cli.py` | 6 Spanish strings in JSON output → English |
+| 2 | HIGH | `detectors/java.py` | `@Controller` detection accepts `@GetMapping`/`@PostMapping`/etc, not just `@RequestMapping` — fixes undercount of controllers |
+| 3 | HIGH | `detectors/java.py`, `classifier.py`, `context_summarizer.py`, `summarizer.py` | Added Thymeleaf/FreeMarker detection; classifier returns `"web_mvc"` for Spring + server-side template apps instead of `"api"` |
+| 4 | MEDIUM | `prepare_context.py` | Dedup `key_dependencies` by name before ranking — mirrors dedup already in cli.py |
+| 5 | MEDIUM | `architecture_analyzer.py` | New `_detect_spring_domain_modules()` — detects petclinic-style domain packages via longest-common-prefix stripping; returns `"spring_mvc_layered"` pattern |
+| 6 | MEDIUM | — | Resolved by Bug #2 (IR controller count now consistent with entry_points) |
+| 7 | LOW | `repository_ir.py` | `_canonical_subsystem_pkg` uses depth 5 for `springframework`/`apache` namespaces so `cross_module_impact.module` shows app modules not framework package names |
+| 8 | LOW | `repository_ir.py` | `mappers_affected.role` defaults to `"repository"` for JPA repos, `"mapper"` only for MyBatis `mapper_interface` symbols |
+| 9 | LOW | — | **SKIPPED** — onboard vs architecture confidence divergence; no acceptance criterion check; low risk |
+
+Version also bumped: 1.32.0 → 1.32.1 (`__init__.py` + `pyproject.toml`).
+
+---
+
+## What remains
+
+### From the bug fix task spec
+- [ ] **Bug #9** (LOW): `onboard.confidence "high"` vs `architecture.confidence "low"` divergence — use min of two, or document. Not in acceptance criteria so deferred.
+- [ ] **Validation**: Run `sourcecode spring-petclinic --agent | jq .` to verify acceptance criteria live:
+  - JSON output 100% English (done statically via grep — passed)
+  - `entry_points.controllers.classes == 6`
+  - `project_type: "web_mvc"`
+  - `key_dependencies` no duplicates
+  - `architecture.pattern: "spring_mvc_layered"`
+
+### From session 29 handoff (pre-existing)
+Three tiering policy gaps — still open:
+- **GAP 1 (easy)**: Add `"upgrade_hint": "sourcecode activate <license_key>"` to JSON payload in `require_feature()` in `license.py:244` — one-liner
+- **GAP 2 (medium)**: Tiered `--help` output (Free shows core commands + lock labels, Pro shows full). Requires custom `--help` callback since `is_pro` unavailable at module init.
+- **GAP 3 (medium)**: Free-tier node cap (max 10) for `--graph-modules` and `--semantics` outputs
+
+### Optional P1 (backlog)
+- `project_summary` quality improvements
+- `relevant_files.score` ranking improvements
+
+---
+
+## Key technical context for next session
+
+### Bug #5 — spring domain detection
+`_detect_spring_domain_modules` in `architecture_analyzer.py`:
+1. Finds longest common path prefix across all source paths
+2. Strips it (e.g. `src/main/java/org/springframework/samples/petclinic/`)
+3. Takes first remaining segment as module name
+4. ≥3 distinct modules with ≥2 files each → returns `"spring_mvc_layered"`
+Pattern priority 3 in `_PATTERN_PRIORITY` (same as `"mvc"`).
+
+### Bug #3 classifier ordering
+`classifier.py._classify_project_type()` order:
+1. `_WEB_FRAMEWORKS` → `"webapp"`
+2. NEW: `_SERVERSIDE_TEMPLATE_FRAMEWORKS` (Thymeleaf, FreeMarker) → `"web_mvc"`
+3. `_API_FRAMEWORKS` (Spring Boot, etc.) → `"api"`
+
+### Bug #7 — framework namespace depth
+Only triggers when `parts[1] in _FRAMEWORK_NS` AND `len(parts) >= 5`.
+`org.keycloak.services.Foo` → parts[1]="keycloak" (not in FRAMEWORK_NS) → unchanged.
+`org.springframework.samples.petclinic.owner.X` → depth 5 → `org.springframework.samples.petclinic.owner`.
+
+### GAP 1 location (license.py:244)
+```python
+payload = {
+    "error": "pro_required",
+    "feature": feature_name,
+    "message": (...),
+    # ADD: "upgrade_hint": "sourcecode activate <license_key>",
+}
+```
+
+---
+
+## Files modified this session
+- `src/sourcecode/__init__.py`
+- `pyproject.toml`
+- `src/sourcecode/architecture_analyzer.py`
+- `src/sourcecode/classifier.py`
+- `src/sourcecode/cli.py`
+- `src/sourcecode/context_summarizer.py`
+- `src/sourcecode/dependency_analyzer.py`
+- `src/sourcecode/detectors/java.py`
+- `src/sourcecode/prepare_context.py`
+- `src/sourcecode/repository_ir.py`
+- `src/sourcecode/summarizer.py`
+
+## Untracked (not part of current work)
+- `docs/PRODUCT_AUDIT.md`
+
+---
+
+## Resume
+```
+/gsd:resume-work
+```

{sourcecode-1.32.0 → sourcecode-1.32.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.32.0
+Version: 1.32.2
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004

{sourcecode-1.32.0 → sourcecode-1.32.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.32.0"
+version = "1.32.2"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.32.0"
+__version__ = "1.32.2"

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/architecture_analyzer.py

@@ -152,14 +152,15 @@ LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
 
 # Higher value = wins when score ties
 _PATTERN_PRIORITY: dict[str, int] = {
-    "cqrs":       8,
-    "clean":      7,
-    "onion":      6,
-    "hexagonal":  5,
-    "monorepo":   4,
-    "mvc":        3,
-    "layered":    2,
-    "fullstack":  1,
+    "cqrs":               8,
+    "clean":              7,
+    "onion":              6,
+    "hexagonal":          5,
+    "monorepo":           4,
+    "spring_mvc_layered": 3,
+    "mvc":                3,
+    "layered":            2,
+    "fullstack":          1,
 }
 
 
@@ -248,9 +249,9 @@ class ArchitectureAnalyzer:
         pattern, layers = self._detect_layers(filtered)
         if pattern in (None, "flat", "unknown"):
             if pattern == "flat":
-                limitations.append("Patron de capas no detectado: proyecto con estructura plana")
+                limitations.append("Layer pattern not detected: project has a flat directory structure")
             elif pattern == "unknown":
-                limitations.append("Patron de capas no reconocido: estructura de directorios sin senales claras")
+                limitations.append("Unrecognized layer pattern: directory structure has no clear architectural signals")
 
         # Step 3b: monorepo override — workspace config is hard evidence.
         # Overrides all weak inferred patterns; only truly specialised patterns
@@ -269,7 +270,7 @@ class ArchitectureAnalyzer:
                 pattern = "monorepo"
                 layers = mono_layers
                 limitations.append(
-                    "Workspace config detectado — arquitectura refleja topologia de paquetes"
+                    "Workspace config detected — architecture reflects package topology"
                 )
                 ws_files = [p for p in sm.file_paths if p.split("/")[-1] in _WORKSPACE_CONFIG_FILES]
                 evidence.append({
@@ -570,28 +571,76 @@ class ArchitectureAnalyzer:
                 ))
             return best_pattern, layers
 
-        # 2. Microservices structural detection (before file-naming heuristics)
+        # 2. Spring domain-module detection (petclinic-style: deep common prefix + feature dirs)
+        spring_result = self._detect_spring_domain_modules(source_paths)
+        if spring_result is not None:
+            return spring_result
+
+        # 3. Microservices structural detection (before file-naming heuristics)
         microservices_result = self._detect_microservices(source_paths)
         if microservices_result is not None:
             return microservices_result
 
-        # 3. Functional file-naming heuristic: *_analyzer.py, cli.py, schema.py, …
+        # 5. Functional file-naming heuristic: *_analyzer.py, cli.py, schema.py, …
         func_result = self._detect_layered_functional(source_paths)
         if func_result is not None:
             return func_result
 
-        # 4. Modular sub-package heuristic: ≥2 distinct named sub-packages
+        # 6. Modular sub-package heuristic: ≥2 distinct named sub-packages
         modular_result = self._detect_modular(source_paths)
         if modular_result is not None:
             return modular_result
 
-        # 5. Fallback: flat (shallow) vs truly unknown (deep but unrecognised)
+        # 7. Fallback: flat (shallow) vs truly unknown (deep but unrecognised)
         max_depth = max(
             (len(p.replace("\\", "/").split("/")) - 1 for p in source_paths),
             default=0,
         )
         return ("flat" if max_depth <= 2 else "unknown"), []
 
+    def _detect_spring_domain_modules(
+        self, paths: list[str]
+    ) -> Optional[tuple[str, list[ArchitectureLayer]]]:
+        """Detect Spring Boot domain-organized packages (petclinic-style).
+
+        When all source paths share a deep common package prefix
+        (e.g. src/main/java/org/springframework/samples/petclinic/),
+        strips that prefix and detects feature/domain modules in the remainder.
+        Requires ≥3 distinct domain directories to avoid false positives.
+        """
+        if len(paths) < 6:
+            return None
+
+        parts_list = [p.replace("\\", "/").split("/") for p in paths]
+        min_depth = min(len(p) for p in parts_list)
+        common_depth = 0
+        for i in range(min_depth - 1):
+            seg = parts_list[0][i]
+            if all(pl[i] == seg for pl in parts_list):
+                common_depth = i + 1
+            else:
+                break
+
+        if common_depth < 3:
+            return None
+
+        module_files: dict[str, list[str]] = {}
+        for orig, pl in zip(paths, parts_list):
+            remaining = pl[common_depth:]
+            if remaining and remaining[0] not in _GENERIC_NAMES:
+                module_files.setdefault(remaining[0], []).append(orig)
+
+        meaningful = {k: v for k, v in module_files.items() if len(v) >= 2}
+        if len(meaningful) < 3:
+            return None
+
+        return "spring_mvc_layered", [
+            ArchitectureLayer(
+                name=k, pattern="spring_mvc_layered", files=v, confidence="medium"
+            )
+            for k, v in meaningful.items()
+        ]
+
     def _detect_microservices(
         self, paths: list[str]
     ) -> Optional[tuple[str, list[ArchitectureLayer]]]:

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/classifier.py

@@ -118,6 +118,10 @@ class TypeClassifier:
         ):
             return "webapp"
 
+        _SERVERSIDE_TEMPLATE_FRAMEWORKS = frozenset({"Thymeleaf", "FreeMarker"})
+        if framework_names & _SERVERSIDE_TEMPLATE_FRAMEWORKS:
+            return "web_mvc"
+
         if framework_names & _API_FRAMEWORKS:
             return "api"
 

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/cli.py

@@ -140,7 +140,21 @@ def _check_pipeline_coherence(sm: "SourceMap") -> list[str]:  # type: ignore[nam
 
     return issues
 
-_HELP = """\
+def _build_help_text() -> str:
+    """Build --help text dynamically based on current license state."""
+    try:
+        from sourcecode.license import is_pro as _is_pro
+    except Exception:
+        _is_pro = False
+
+    if _is_pro:
+        plan_badge = "[bold green]● Pro[/bold green]"
+    else:
+        plan_badge = "[yellow]Free[/yellow]  ·  [dim]sourcecode activate <key>[/dim] to unlock Pro"
+
+    text = f"""\
+[bold]sourcecode[/bold]  {plan_badge}
+
 Deterministic codebase context for AI coding agents.
 
 [bold]Primary usage:[/bold]
@@ -164,6 +178,26 @@ Deterministic codebase context for AI coding agents.
   version
 """
 
+    if not _is_pro:
+        text += """\
+
+[dim bold]Locked (Pro):[/dim bold]
+  [dim]impact                              blast radius before any change[/dim]
+  [dim]modernize (full)                    dead zones, tangles, full coupling[/dim]
+  [dim]fix-bug (full)                      complete risk-ranked file list[/dim]
+  [dim]review-pr (expanded)               CI-grade PR review[/dim]
+  [dim]prepare-context delta               incremental context for CI/CD[/dim]
+  [dim]prepare-context generate-tests      test gap analysis[/dim]
+  [dim]--full                              removes all truncation limits[/dim]
+
+  [dim cyan]→ sourcecode activate <key>[/dim cyan]
+"""
+
+    return text
+
+
+_HELP = _build_help_text()
+
 # Known subcommand names — tokens matching these are routed as subcommands,
 # not consumed as a repository path.
 _SUBCOMMANDS: frozenset[str] = frozenset(
@@ -344,6 +378,10 @@ def _get_command_with_preprocessing(typer_instance: Any) -> Any:
     cmd = _orig_get_command(typer_instance)
     if typer_instance is not app:
         return cmd  # only wrap the root app, not telemetry_app etc.
+
+    # Refresh help text at invocation time so it reflects current license state.
+    cmd.help = _build_help_text()
+
     _orig_cmd_main = cmd.main
 
     def _cmd_main(args: Optional[list[str]] = None, **kwargs: Any) -> Any:
@@ -2011,6 +2049,15 @@ def main(
         except Exception:
             pass  # non-fatal: cache write failure
 
+    # Update RIS with aggregated snapshot data (non-fatal side-effect).
+    if not no_cache and not _pipeline_error and _core_key:
+        try:
+            from sourcecode.serializer import core_view as _ris_core_view
+            from sourcecode.ris import maybe_update_ris as _ris_update
+            _ris_update(target, _ris_core_view(sm), _git_sha)
+        except Exception:
+            pass
+
     if _pipeline_error:
         raise typer.Exit(code=2)
 
@@ -3147,6 +3194,14 @@ def endpoints_cmd(
         raise typer.Exit(code=1)
 
     data = _extract_java_endpoints(target)
+
+    # Update RIS api_surface section (non-fatal side-effect).
+    try:
+        from sourcecode.ris import update_ris_api_surface as _ris_ep
+        _ris_ep(target, data)
+    except Exception:
+        pass
+
     output = _serialize_dict(data, format)
 
     if output_path is not None:
@@ -3824,7 +3879,7 @@ def mcp_init(
         raise typer.Exit(code=1)
 
     typer.echo("MCP integration active.")
-    typer.echo("  Note:    repo_path debe usar forward slashes: C:/Users/... o /ruta/unix")
+    typer.echo("  Note:    repo_path must use forward slashes: C:/Users/... or /unix/path")
     typer.echo("")
 
     # Post-write: validate config and warn if client not running
@@ -3976,7 +4031,7 @@ def mcp_status() -> None:
     typer.echo(sep)
     typer.echo("  Note:    'configured' and 'running' are checked independently.")
     typer.echo("           A running app still needs restart after first-time config.")
-    typer.echo("  Path:    repo_path debe usar forward slashes: C:/Users/... o /ruta/unix")
+    typer.echo("  Path:    repo_path must use forward slashes: C:/Users/... or /unix/path")
     typer.echo("  Setup:   sourcecode mcp init")
     typer.echo("  Remove:  sourcecode mcp remove")
 

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/context_summarizer.py

@@ -28,6 +28,7 @@ _STACK_LABELS: dict[str, str] = {
 
 _TYPE_LABELS: dict[str, str] = {
     "api": "REST API",
+    "web_mvc": "Spring MVC web app",
     "webapp": "Web app",
     "fullstack": "Full-stack app",
     "cli": "CLI tool",

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/dependency_analyzer.py

@@ -1118,7 +1118,7 @@ class DependencyAnalyzer:
         try:
             tree = ET.parse(pom)
         except (ET.ParseError, OSError):
-            return [], ["java: error al parsear pom.xml"]
+            return [], ["java: error parsing pom.xml"]
 
         root_elem = tree.getroot()
         ns_match = re.match(r"\{[^}]+\}", root_elem.tag)
@@ -1217,10 +1217,10 @@ class DependencyAnalyzer:
                 try:
                     content = gradle_file.read_text(encoding="utf-8", errors="replace")
                 except OSError:
-                    return [], [f"gradle: error al leer {filename}"]
+                    return [], [f"gradle: error reading {filename}"]
                 props = self._parse_gradle_properties(root, content)
                 records = self._parse_gradle_dependencies(content, props, filename)
-                return records, ["gradle: sin lockfile compatible; dependencias transitivas no disponibles"]
+                return records, ["gradle: no compatible lockfile found; transitive dependencies unavailable"]
         return [], []
 
     def _parse_gradle_properties(self, root: Path, content: str) -> dict[str, str]:

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/detectors/java.py

@@ -23,6 +23,7 @@ _MAX_ANNOTATION_ENTRY_POINTS = 1000
 _REST_CONTROLLER_RE = re.compile(r'@RestController\b')
 _MVC_CONTROLLER_RE = re.compile(r'@Controller\b')
 _REQUEST_MAPPING_RE = re.compile(r'@RequestMapping\b')
+_ANY_MAPPING_RE = re.compile(r'@(?:Request|Get|Post|Put|Delete|Patch)Mapping\b')
 _CONTROLLER_ADVICE_RE = re.compile(r'@ControllerAdvice\b')
 _WEB_FILTER_RE = re.compile(r'@WebFilter\b')
 _FILTER_BEAN_RE = re.compile(r'FilterRegistrationBean\b')
@@ -298,6 +299,10 @@ class JavaDetector(AbstractDetector):
             frameworks.append(FrameworkDetection(name="Jakarta EE", source=source))
         if "mybatis" in text:
             frameworks.append(FrameworkDetection(name="MyBatis", source=source))
+        if "thymeleaf" in text:
+            frameworks.append(FrameworkDetection(name="Thymeleaf", source=source))
+        if "freemarker" in text:
+            frameworks.append(FrameworkDetection(name="FreeMarker", source=source))
         if "spring-boot-starter-security" in text or "spring-security-core" in text:
             frameworks.append(FrameworkDetection(name="Spring Security", source=source))
         if "spring-boot-starter-data-jpa" in text or "spring-data-jpa" in text:
@@ -470,7 +475,7 @@ class JavaDetector(AbstractDetector):
                 path=rel_path, stack="java", kind="exception_handler",
                 source="annotation", confidence="medium",
             )]
-        if _MVC_CONTROLLER_RE.search(content) and _REQUEST_MAPPING_RE.search(content):
+        if _MVC_CONTROLLER_RE.search(content) and _ANY_MAPPING_RE.search(content):
             http_path_match = _HTTP_PATH_RE.search(content)
             http_path = http_path_match.group(1) if http_path_match else None
             verb_match = _REQUEST_METHOD_VERB_RE.search(content)

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/mcp/server.py

@@ -109,6 +109,42 @@ def _check_repo_path(path: str) -> "CallToolResult | None":
     return None
 
 
+@mcp.tool()
+def get_cold_start_context(repo_path: str = ".") -> dict:
+    """Instant session bootstrap from persisted Repository Intelligence Snapshot (RIS).
+
+    CALL THIS FIRST at the start of every MCP session.  Returns cached structural
+    context built from prior analysis runs — zero re-analysis cost.
+
+    status values:
+      "cold_start_ready"  — RIS exists and matches the current git HEAD.
+      "cold_start_stale"  — RIS exists but HEAD has changed since last analysis.
+                            Data is still useful; run get_compact_context to refresh.
+      "no_ris"            — No RIS yet for this repo; run get_compact_context first.
+
+    Returns: status, repo_id, git_head, stale (bool), last_updated_at,
+             summary (compact snapshot), entrypoints, endpoints, hotspots.
+
+    repo_path: absolute path to the repository (default: current working directory).
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from pathlib import Path as _Path
+        from sourcecode.ris import get_cold_start_context as _gcs
+        return _ok(_gcs(_Path(repo_path)))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
 @mcp.tool()
 def get_compact_context(repo_path: str = ".", git_context: bool = False) -> dict:
     """Compact human/LLM summary of a repository (~1000-3000 tokens). USE THIS FIRST.

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/prepare_context.py

@@ -981,12 +981,18 @@ class TaskContextBuilder:
 
             dep_records, dep_summary = DependencyAnalyzer().analyze(self.root)
             primary_eco = stacks[0].stack if stacks else ""
-            direct = [
+            _direct_raw = [
                 d for d in dep_records
                 if d.scope != "transitive" and d.source in {"manifest", "lockfile"}
                 and (d.role or "unknown") in {"runtime", "parsing", "serialization", "observability", "infra"}
                 and d.scope not in {"dev"}
             ]
+            _seen_dep: set[str] = set()
+            direct = []
+            for _d in _direct_raw:
+                if _d.name not in _seen_dep:
+                    _seen_dep.add(_d.name)
+                    direct.append(_d)
             # Rank by framework centrality: core infra (ORM, Spring) > serialization > other.
             # Penalise vendored tooling (closure-compiler, shaded utilities) so that
             # Hibernate/JPA/Solr appear before minor build-time dependencies.

{sourcecode-1.32.0 → sourcecode-1.32.2}/src/sourcecode/repository_ir.py

@@ -1697,6 +1697,9 @@ def _canonical_subsystem_pkg(fqn: str) -> str:
     (even if uppercase) to force at least 2-segment grouping.
     """
     _TOP_LEVEL = {"com", "org", "net", "io", "java", "javax"}
+    # Well-known framework namespaces that are not application boundaries;
+    # go one level deeper (depth 5) so callers get the actual app module.
+    _FRAMEWORK_NS = {"springframework", "apache", "eclipse", "google", "jetbrains"}
     parts: list[str] = []
     for segment in fqn.split("."):
         if "#" in segment or (segment and segment[0].isupper()):
@@ -1705,6 +1708,8 @@ def _canonical_subsystem_pkg(fqn: str) -> str:
     if not parts:
         return fqn.rsplit(".", 1)[0] if "." in fqn else fqn
     if parts[0] in _TOP_LEVEL and len(parts) >= 3:
+        if len(parts) >= 5 and len(parts) > 3 and parts[1] in _FRAMEWORK_NS:
+            return ".".join(parts[:5])
         return ".".join(parts[:3])
     # Prevent bare TLD collapse: "org" or "com" alone as subsystem key is meaningless
     # and groups ALL classes under that TLD into a single giant component.
@@ -3338,7 +3343,7 @@ def compute_blast_radius(
             _seen_mapper_fqns.add(fqn)
             _mapper_entry: dict = {
                 "fqn": fqn,
-                "role": role or "mapper",
+                "role": role or ("mapper" if symbol_kind == "mapper_interface" else "repository"),
                 "source_file": node_dict.get("source_file") or "",
             }
             if canonical != fqn: