refactor(renderer): align clone detection wording across surfaces

Author: flamehaven01

src/slop_detector/renderer_glossary.py

@@ -28,6 +28,14 @@
     "How structurally connected the project's files are to each other; "
     "higher means more cohesive."
 )
+_MEANS_EXACT_DUPLICATE = (
+    "Two or more functions in this file are exact duplicates after normalizing "
+    "local names and parameters."
+)
+_MEANS_CLONE_CLUSTER = (
+    "Several functions in this file share almost the same AST structure and "
+    "should be reviewed for copy-paste fragmentation."
+)
 
 
 def _deficit_health(value: float) -> str:
@@ -99,7 +107,7 @@ def file_metric_rows(fr: Any) -> List[Dict[str, str]]:
     """Per-file metric descriptors (reuses the project-level health bands and
     meanings). A single file has no weighted aggregate, so only the four core
     dimensions are reported."""
-    return [
+    rows = [
         {
             "label": "Deficit Score",
             "value": f"{fr.deficit_score:.1f}/100",
@@ -129,6 +137,45 @@ def file_metric_rows(fr: Any) -> List[Dict[str, str]]:
             "means": _MEANS_DDC,
         },
     ]
+    clone_row = clone_metric_row(fr)
+    if clone_row:
+        rows.append(clone_row)
+    return rows
+
+
+def clone_metric_row(fr: Any) -> Dict[str, str] | None:
+    clone_issues = [
+        issue
+        for issue in getattr(fr, "pattern_issues", []) or []
+        if getattr(issue, "pattern_id", None) in {"function_clone_cluster", "exact_duplicate_pair"}
+    ]
+    if not clone_issues:
+        return None
+
+    top = max(clone_issues, key=_clone_issue_rank)
+    pattern_id = getattr(top, "pattern_id", "")
+    severity = str(getattr(getattr(top, "severity", None), "value", "warning")).lower()
+    health = "bad" if severity == "critical" else "warn"
+    if pattern_id == "exact_duplicate_pair":
+        value = f"{severity.upper()} - exact duplicate functions"
+        means = _MEANS_EXACT_DUPLICATE
+    else:
+        value = f"{severity.upper()} - near-identical function cluster"
+        means = _MEANS_CLONE_CLUSTER
+    return {
+        "label": "Clone Detection",
+        "value": value,
+        "direction": "Lower",
+        "health": health,
+        "means": means,
+    }
+
+
+def _clone_issue_rank(issue: Any) -> tuple[int, int]:
+    severity = str(getattr(getattr(issue, "severity", None), "value", "")).lower()
+    severity_rank = {"critical": 2, "high": 1}.get(severity, 0)
+    pattern_rank = 1 if getattr(issue, "pattern_id", "") == "exact_duplicate_pair" else 0
+    return severity_rank, pattern_rank
 
 
 def coherence_display(result: Any) -> Dict[str, str]:

src/slop_detector/renderer_rich.py

@@ -8,6 +8,7 @@
 from slop_detector.question_generator import QuestionGenerator
 from slop_detector.renderer_glossary import (
     DEFICIT_BANDS,
+    clone_metric_row,
     coherence_display,
     file_metric_rows,
     next_steps,
@@ -319,23 +320,22 @@ def _build_metrics_table(result) -> "Table":
             "Optional ML secondary signal.",
         )
 
-    clone_pattern_ids = {"function_clone_cluster", "exact_duplicate_pair"}
-    clone_issues = [
-        i
-        for i in getattr(result, "pattern_issues", [])
-        if getattr(i, "pattern_id", None) in clone_pattern_ids
-    ]
-    if clone_issues:
-        top = clone_issues[0]
-        sev = getattr(top, "severity", None)
-        sev_val = sev.value if sev is not None else ""
-        clone_color = "red" if sev_val == "critical" else "yellow"
+    clone_row = clone_metric_row(result)
+    if clone_row:
+        clone_color = "red" if clone_row["health"] == "bad" else "yellow"
         t.add_row(
             "Clone Detection:",
-            f"[{clone_color}]{sev_val.upper()} — structural duplicates detected[/{clone_color}]",
+            f"[{clone_color}]{clone_row['value']}[/{clone_color}]",
+            clone_row["direction"],
+            clone_row["means"],
         )
     else:
-        t.add_row("Clone Detection:", "[green]PASS[/green]")
+        t.add_row(
+            "Clone Detection:",
+            "[green]PASS[/green]",
+            "Lower",
+            "No exact duplicate pair or near-identical function cluster was detected.",
+        )
 
     return t
 

tests/test_cli.py

@@ -80,6 +80,7 @@ def test_generate_text_report_single_file():
         deficit_score=25.0,
         status=SlopStatus.CLEAN,
         warnings=["Test warning"],
+        pattern_issues=[],
     )
 
     report = generate_text_report(result)
@@ -252,6 +253,58 @@ def test_generate_markdown_report_single_file():
     assert "file.py" in report
 
 
+def test_generate_text_report_single_file_shows_exact_duplicate_clone_row():
+    result = FileAnalysis(
+        file_path="/test/file.py",
+        ldr=LDRResult(100, 80, 20, 0.80, "A"),
+        inflation=InflationResult(5, 2.0, 0.5, "PASS", ["neural"], []),
+        ddc=DDCResult(["numpy"], ["numpy"], [], [], [], 1.0, "EXCELLENT"),
+        deficit_score=25.0,
+        status=SlopStatus.CLEAN,
+        warnings=[],
+        pattern_issues=[
+            type(
+                "Issue",
+                (),
+                {
+                    "pattern_id": "exact_duplicate_pair",
+                    "severity": type("Severity", (), {"value": "high"})(),
+                },
+            )()
+        ],
+    )
+
+    report = generate_text_report(result)
+    assert "Clone Detection" in report
+    assert "exact duplicate functions" in report
+
+
+def test_generate_markdown_report_single_file_shows_clone_cluster_row():
+    result = FileAnalysis(
+        file_path="/test/file.py",
+        ldr=LDRResult(100, 80, 20, 0.80, "A"),
+        inflation=InflationResult(5, 2.0, 0.5, "PASS", ["neural"], []),
+        ddc=DDCResult(["numpy"], ["numpy"], [], [], [], 1.0, "EXCELLENT"),
+        deficit_score=25.0,
+        status=SlopStatus.CLEAN,
+        warnings=[],
+        pattern_issues=[
+            type(
+                "Issue",
+                (),
+                {
+                    "pattern_id": "function_clone_cluster",
+                    "severity": type("Severity", (), {"value": "critical"})(),
+                },
+            )()
+        ],
+    )
+
+    report = generate_markdown_report(result)
+    assert "Clone Detection" in report
+    assert "near-identical function cluster" in report
+
+
 def test_generate_markdown_report_project():
     """Test generate_markdown_report for project."""
     file_result = FileAnalysis(

tests/test_renderer_glossary.py

@@ -4,6 +4,7 @@
 
 from slop_detector.renderer_glossary import (
     DEFICIT_BANDS,
+    clone_metric_row,
     file_metric_rows,
     next_steps,
     project_metric_rows,
@@ -101,6 +102,7 @@ def test_file_metric_rows_shape_and_shared_bands():
         ldr=SimpleNamespace(ldr_score=0.30),
         inflation=SimpleNamespace(inflation_score=2.0),
         ddc=SimpleNamespace(usage_ratio=0.30),
+        pattern_issues=[],
     )
     rows = file_metric_rows(fr)
     assert [r["label"] for r in rows][0] == "Deficit Score"
@@ -113,6 +115,30 @@ def test_file_metric_rows_shape_and_shared_bands():
     assert all(r["health"] == "bad" for r in rows)
 
 
+def test_clone_metric_row_distinguishes_exact_duplicate_pair():
+    issue = SimpleNamespace(
+        pattern_id="exact_duplicate_pair",
+        severity=SimpleNamespace(value="high"),
+    )
+    row = clone_metric_row(SimpleNamespace(pattern_issues=[issue]))
+    assert row is not None
+    assert row["label"] == "Clone Detection"
+    assert "exact duplicate functions" in row["value"]
+    assert "normalizing local names" in row["means"]
+
+
+def test_clone_metric_row_distinguishes_clone_cluster():
+    issue = SimpleNamespace(
+        pattern_id="function_clone_cluster",
+        severity=SimpleNamespace(value="critical"),
+    )
+    row = clone_metric_row(SimpleNamespace(pattern_issues=[issue]))
+    assert row is not None
+    assert "near-identical function cluster" in row["value"]
+    assert "AST structure" in row["means"]
+    assert row["health"] == "bad"
+
+
 def test_next_steps_ddc_concern_recommends_unused_deps():
     steps = next_steps(_result(avg_ddc=0.30, deficit_files=1, priority_hotspots=[]))
     assert any("unused-deps" in s for s in steps)