redup 0.1.2__tar.gz → 0.1.4__tar.gz

{redup-0.1.2 → redup-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redup
-Version: 0.1.2
+Version: 0.1.4
 Summary: Code duplication analyzer and refactoring planner for LLMs
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0

{redup-0.1.2 → redup-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redup"
-version = "0.1.2"
+version = "0.1.4"
 description = "Code duplication analyzer and refactoring planner for LLMs"
 readme = "README.md"
 license = "Apache-2.0"

{redup-0.1.2 → redup-0.1.4}/src/redup/__init__.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"
 
 from redup.core.models import (
     DuplicateFragment,

{redup-0.1.2 → redup-0.1.4}/src/redup/core/hasher.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 
-import hashlib
-import re
 from collections import defaultdict
+from collections.abc import Callable
 from dataclasses import dataclass, field
+import hashlib
+import re
 
 from redup.core.scanner import CodeBlock
 
@@ -61,6 +62,60 @@ def _ast_to_normalized_string(tree: object) -> str:
     """
     import ast
 
+    name_map: dict[str, str] = {}
+    counter = [0]
+    parts: list[str] = []
+    
+    for node in ast.walk(tree):
+        part = _process_ast_node(node, name_map, counter)
+        if part:
+            parts.append(part)
+    
+    return " ".join(parts)
+
+
+def _process_ast_node(
+    node, 
+    name_map: dict[str, str], 
+    counter: list[int]
+) -> str | None:
+    """Process a single AST node and return its normalized representation."""
+    import ast
+    
+    if isinstance(node, ast.Name):
+        return _get_placeholder(node.id, name_map, counter)
+    elif isinstance(node, ast.arg):
+        return _get_placeholder(node.arg, name_map, counter)
+    elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        return f"DEF({_get_placeholder(node.name, name_map, counter)})"
+    elif isinstance(node, ast.ClassDef):
+        return f"CLASS({_get_placeholder(node.name, name_map, counter)})"
+    elif isinstance(node, ast.Constant):
+        return _normalize_constant(node.value)
+    elif isinstance(node, ast.If):
+        return "IF"
+    elif isinstance(node, ast.For):
+        return "FOR"
+    elif isinstance(node, ast.While):
+        return "WHILE"
+    elif isinstance(node, ast.Return):
+        return "RETURN"
+    elif isinstance(node, ast.Compare):
+        ops = [type(op).__name__ for op in node.ops]
+        return f"CMP({','.join(ops)})"
+    elif isinstance(node, ast.BinOp):
+        return f"BINOP({type(node.op).__name__})"
+    elif isinstance(node, ast.Call):
+        return "CALL"
+    return None
+
+
+def _get_placeholder(
+    name: str, 
+    name_map: dict[str, str], 
+    counter: list[int]
+) -> str:
+    """Get or create a placeholder for a name."""
     BUILTINS = {
         "print", "len", "range", "int", "float", "str", "list", "dict",
         "set", "tuple", "bool", "None", "True", "False", "type", "isinstance",
@@ -72,57 +127,28 @@ def _ast_to_normalized_string(tree: object) -> str:
         "class", "def", "pass", "break", "continue", "and", "or", "not",
         "in", "is", "lambda", "global", "nonlocal", "assert", "del",
     }
-
-    name_map: dict[str, str] = {}
-    counter = [0]
-
-    def _get_placeholder(name: str) -> str:
-        if name in BUILTINS:
-            return name
-        if name.startswith("__") and name.endswith("__"):
-            return name
-        if name not in name_map:
-            name_map[name] = f"_V{counter[0]}"
-            counter[0] += 1
-        return name_map[name]
-
-    parts: list[str] = []
-    for node in ast.walk(tree):
-        if isinstance(node, ast.Name):
-            parts.append(_get_placeholder(node.id))
-        elif isinstance(node, ast.arg):
-            parts.append(_get_placeholder(node.arg))
-        elif isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
-            parts.append(f"DEF({_get_placeholder(node.name)})")
-        elif isinstance(node, ast.ClassDef):
-            parts.append(f"CLASS({_get_placeholder(node.name)})")
-        elif isinstance(node, ast.Constant):
-            if isinstance(node.value, str):
-                parts.append("__STR__")
-            elif isinstance(node.value, (int, float)):
-                parts.append("__NUM__")
-            else:
-                parts.append(str(type(node.value).__name__))
-        elif isinstance(node, ast.If):
-            parts.append("IF")
-        elif isinstance(node, ast.For):
-            parts.append("FOR")
-        elif isinstance(node, ast.While):
-            parts.append("WHILE")
-        elif isinstance(node, ast.Return):
-            parts.append("RETURN")
-        elif isinstance(node, ast.Compare):
-            ops = [type(op).__name__ for op in node.ops]
-            parts.append(f"CMP({','.join(ops)})")
-        elif isinstance(node, ast.BinOp):
-            parts.append(f"BINOP({type(node.op).__name__})")
-        elif isinstance(node, ast.Call):
-            parts.append("CALL")
-
-    return " ".join(parts)
-
-
-def _hash_text(text: str, normalizer: callable) -> str:
+    
+    if name in BUILTINS or (name.startswith("__") and name.endswith("__")):
+        return name
+    
+    if name not in name_map:
+        name_map[name] = f"_V{counter[0]}"
+        counter[0] += 1
+    
+    return name_map[name]
+
+
+def _normalize_constant(value) -> str:
+    """Normalize constant values."""
+    if isinstance(value, str):
+        return "__STR__"
+    elif isinstance(value, (int, float)):
+        return "__NUM__"
+    else:
+        return str(type(value).__name__)
+
+
+def _hash_text(text: str, normalizer: Callable[[str], str]) -> str:
     """Generic SHA-256 hash function with configurable normalizer."""
     normalized = normalizer(text)
     return hashlib.sha256(normalized.encode("utf-8")).hexdigest()[:16]
@@ -138,6 +164,14 @@ def hash_block_structural(text: str) -> str:
     return _hash_text(text, _normalize_ast_text)
 
 
+def _hashed_block(block: CodeBlock) -> HashedBlock:
+    return HashedBlock(
+        block=block,
+        exact_hash=hash_block(block.text),
+        structural_hash=hash_block_structural(block.text),
+    )
+
+
 @dataclass
 class HashedBlock:
     """A code block with its computed fingerprints."""
@@ -167,11 +201,7 @@ def build_hash_index(blocks: list[CodeBlock], min_lines: int = 3) -> HashIndex:
         if block.line_count < min_lines:
             continue
 
-        hb = HashedBlock(
-            block=block,
-            exact_hash=hash_block(block.text),
-            structural_hash=hash_block_structural(block.text),
-        )
+        hb = _hashed_block(block)
 
         index.exact[hb.exact_hash].append(hb)
         index.structural[hb.structural_hash].append(hb)

{redup-0.1.2 → redup-0.1.4}/src/redup/core/matcher.py

@@ -2,8 +2,9 @@
 
 from __future__ import annotations
 
-import difflib
+from collections.abc import Callable
 from dataclasses import dataclass
+import difflib
 
 from redup.core.hasher import HashedBlock, _normalize_text
 
@@ -39,14 +40,13 @@ def fuzzy_similarity(text_a: str, text_b: str) -> float:
         return sequence_similarity(text_a, text_b)
 
 
-def match_candidates(
+def _compare_against_reference(
     candidates: list[HashedBlock],
-    min_similarity: float = 0.85,
+    min_similarity: float,
+    similarity_fn: Callable[[str, str], float],
+    method_fn: Callable[[float], str],
+    skip_same_location: bool = False,
 ) -> list[MatchResult]:
-    """Compare all pairs in a candidate group and return matches above threshold.
-
-    Uses the first block as reference and compares all others against it.
-    """
     if len(candidates) < 2:
         return []
 
@@ -54,16 +54,41 @@ def match_candidates(
     ref = candidates[0]
 
     for other in candidates[1:]:
-        sim = fuzzy_similarity(ref.block.text, other.block.text)
+        if skip_same_location and (
+            ref.block.file == other.block.file and ref.block.line_start == other.block.line_start
+        ):
+            continue
+
+        sim = similarity_fn(ref.block.text, other.block.text)
         if sim >= min_similarity:
-            method = "exact" if sim >= 0.999 else "fuzzy"
-            results.append(MatchResult(
-                block_a=ref, block_b=other, similarity=sim, method=method
-            ))
+            results.append(
+                MatchResult(
+                    block_a=ref,
+                    block_b=other,
+                    similarity=sim,
+                    method=method_fn(sim),
+                )
+            )
 
     return results
 
 
+def match_candidates(
+    candidates: list[HashedBlock],
+    min_similarity: float = 0.85,
+) -> list[MatchResult]:
+    """Compare all pairs in a candidate group and return matches above threshold.
+
+    Uses the first block as reference and compares all others against it.
+    """
+    return _compare_against_reference(
+        candidates,
+        min_similarity,
+        fuzzy_similarity,
+        lambda sim: "exact" if sim >= 0.999 else "fuzzy",
+    )
+
+
 def refine_structural_matches(
     candidates: list[HashedBlock],
     min_similarity: float = 0.80,
@@ -73,19 +98,10 @@ def refine_structural_matches(
     Structural hashes normalize variable names, so we use a lower threshold
     and verify the overall shape matches.
     """
-    if len(candidates) < 2:
-        return []
-
-    results: list[MatchResult] = []
-    ref = candidates[0]
-
-    for other in candidates[1:]:
-        if ref.block.file == other.block.file and ref.block.line_start == other.block.line_start:
-            continue
-        sim = sequence_similarity(ref.block.text, other.block.text)
-        if sim >= min_similarity:
-            results.append(MatchResult(
-                block_a=ref, block_b=other, similarity=sim, method="structural"
-            ))
-
-    return results
+    return _compare_against_reference(
+        candidates,
+        min_similarity,
+        sequence_similarity,
+        lambda _sim: "structural",
+        skip_same_location=True,
+    )

redup-0.1.4/src/redup/core/pipeline.py

@@ -0,0 +1,266 @@
+"""Pipeline — orchestrates scan → hash → match → group → plan."""
+
+from __future__ import annotations
+
+from redup.core.hasher import (
+    HashIndex,
+    HashedBlock,
+    build_hash_index,
+    find_exact_duplicates,
+    find_structural_duplicates,
+)
+from redup.core.matcher import MatchResult, refine_structural_matches
+from redup.core.models import (
+    DuplicateFragment,
+    DuplicateGroup,
+    DuplicateType,
+    DuplicationMap,
+    ScanConfig,
+)
+from redup.core.planner import generate_suggestions
+from redup.core.scanner import CodeBlock, ScannedFile, ScanStats, scan_project
+
+
+def _blocks_to_group(
+    group_id: str,
+    blocks: list[HashedBlock],
+    dup_type: DuplicateType,
+    similarity: float = 1.0,
+    normalized_hash: str = "",
+) -> DuplicateGroup:
+    """Convert a list of hashed blocks into a DuplicateGroup."""
+    # Deduplicate by file+line
+    seen: set[tuple[str, int]] = set()
+    fragments: list[DuplicateFragment] = []
+
+    for hb in blocks:
+        # Handle both HashedBlock and MatchResult objects
+        if hasattr(hb, 'block'):
+            # HashedBlock object
+            block = hb.block
+        elif hasattr(hb, 'block_a'):
+            # MatchResult object - use block_a
+            block = hb.block_a.block
+        else:
+            continue  # Skip unknown object types
+            
+        key = (block.file, block.line_start)
+        if key in seen:
+            continue
+        seen.add(key)
+        fragments.append(
+            DuplicateFragment(
+                file=block.file,
+                line_start=block.line_start,
+                line_end=block.line_end,
+                text=block.text,
+                function_name=block.function_name,
+                class_name=block.class_name,
+            )
+        )
+
+    if len(fragments) < 2:
+        return DuplicateGroup(id=group_id, duplicate_type=dup_type)
+
+    name = fragments[0].function_name if fragments[0].function_name else None
+
+    return DuplicateGroup(
+        id=group_id,
+        duplicate_type=dup_type,
+        fragments=fragments,
+        similarity_score=similarity,
+        normalized_hash=normalized_hash,
+        normalized_name=name,
+    )
+
+
+def _deduplicate_groups(groups: list[DuplicateGroup]) -> list[DuplicateGroup]:
+    """Remove groups that are subsets of larger groups."""
+    if not groups:
+        return groups
+
+    # Sort by impact (largest first)
+    sorted_groups = sorted(groups, key=lambda g: g.impact_score, reverse=True)
+    kept: list[DuplicateGroup] = []
+    seen_locations: set[tuple[str, int, int]] = set()
+
+    for group in sorted_groups:
+        if group.occurrences < 2:
+            continue
+
+        # Check if this group's fragments are already covered
+        locations = {
+            (f.file, f.line_start, f.line_end)
+            for f in group.fragments
+        }
+        new_locations = locations - seen_locations
+
+        if len(new_locations) >= 2:
+            kept.append(group)
+            seen_locations.update(locations)
+
+    return kept
+
+
+def analyze(
+    config: ScanConfig | None = None,
+    function_level_only: bool = False,
+) -> DuplicationMap:
+    """Run the full reDUP analysis pipeline.
+
+    Args:
+        config: Scan configuration. Defaults to current directory, .py files.
+        function_level_only: If True, only analyze function-level blocks
+            (skip sliding-window line blocks). Faster but misses inline duplicates.
+
+    Returns:
+        A DuplicationMap with all duplicate groups and refactoring suggestions.
+    """
+    config = _ensure_config(config)
+    
+    # Phase 1: Scan
+    scanned_files, stats = _scan_phase(config)
+    
+    # Phase 2: Process blocks
+    all_blocks = _process_blocks(scanned_files, function_level_only)
+    
+    # Phase 3: Hash and find duplicates
+    groups = _find_duplicates_phase(all_blocks, config)
+    
+    # Phase 4: Deduplicate and suggest
+    final_groups = _deduplicate_phase(groups)
+
+    dup_map = DuplicationMap(
+        project_path=config.root.as_posix(),
+        config=config,
+        stats=stats,
+        groups=final_groups,
+    )
+    dup_map.suggestions = generate_suggestions(dup_map)
+
+    return dup_map
+
+
+def _ensure_config(config: ScanConfig | None) -> ScanConfig:
+    """Ensure we have a valid configuration."""
+    return config or ScanConfig()
+
+
+def _scan_phase(config: ScanConfig) -> tuple[list[ScannedFile], ScanStats]:
+    """Phase 1: Scan project files."""
+    return scan_project(config)
+
+
+def _process_blocks(
+    scanned_files: list[ScannedFile], 
+    function_level_only: bool
+) -> list[CodeBlock]:
+    """Phase 2: Extract and filter code blocks."""
+    all_blocks: list[CodeBlock] = []
+    for sf in scanned_files:
+        for block in sf.blocks:
+            if function_level_only and block.function_name is None:
+                continue
+            all_blocks.append(block)
+    return all_blocks
+
+
+def _find_duplicates_phase(
+    all_blocks: list[CodeBlock], 
+    config: ScanConfig
+) -> list[DuplicateGroup]:
+    """Phase 3: Hash and find duplicate groups."""
+    index = build_hash_index(all_blocks, min_lines=config.min_block_lines)
+    
+    # Find exact duplicates
+    exact_groups = _find_exact_groups(index)
+    
+    # Find structural duplicates
+    structural_groups = _find_structural_groups(index, exact_groups)
+    
+    return exact_groups + structural_groups
+
+
+def _find_exact_groups(index: HashIndex) -> list[DuplicateGroup]:
+    """Find exact duplicate groups."""
+    groups = []
+    exact_groups = find_exact_duplicates(index)
+    
+    for i, (h, blocks) in enumerate(exact_groups.items(), 1):
+        func_blocks = [b for b in blocks if b.block.function_name]
+        if len(func_blocks) >= 2:
+            g = _blocks_to_group(
+                group_id=f"E{i:04d}",
+                blocks=func_blocks,
+                dup_type=DuplicateType.EXACT,
+                normalized_hash=h,
+            )
+            if g.occurrences >= 2:
+                groups.append(g)
+    
+    return groups
+
+
+def _find_structural_groups(
+    index: HashIndex, 
+    exact_groups_list: list[DuplicateGroup]
+) -> list[DuplicateGroup]:
+    """Find structural duplicate groups."""
+    groups = []
+    exact_hashes = set()
+    for group in exact_groups_list:
+        exact_hashes.add(group.normalized_hash)
+    
+    structural_groups = find_structural_duplicates(index)
+    
+    for i, (h, blocks) in enumerate(structural_groups.items(), 1):
+        if h in exact_hashes:
+            continue
+            
+        func_blocks = [b for b in blocks if b.block.function_name]
+        if len(func_blocks) >= 2:
+            refined = refine_structural_matches(func_blocks)
+            refined_blocks = _match_results_to_blocks(refined)
+            if len(refined_blocks) >= 2:
+                g = _blocks_to_group(
+                    group_id=f"S{i:04d}",
+                    blocks=refined_blocks,
+                    dup_type=DuplicateType.STRUCTURAL,
+                    normalized_hash=h,
+                    similarity=_calculate_similarity(refined),
+                )
+                if g.occurrences >= 2:
+                    groups.append(g)
+    
+    return groups
+
+
+def _deduplicate_phase(groups: list[DuplicateGroup]) -> list[DuplicateGroup]:
+    """Phase 4: Remove overlapping groups."""
+    return _deduplicate_groups(groups)
+
+
+def _match_results_to_blocks(matches: list[MatchResult]) -> list[HashedBlock]:
+    """Flatten a list of pairwise matches into unique hashed blocks."""
+    seen: set[tuple[str, int]] = set()
+    blocks: list[HashedBlock] = []
+
+    for match in matches:
+        for candidate in (match.block_a, match.block_b):
+            key = (candidate.block.file, candidate.block.line_start)
+            if key in seen:
+                continue
+            seen.add(key)
+            blocks.append(candidate)
+
+    return blocks
+
+
+def _calculate_similarity(matches: list[MatchResult]) -> float:
+    """Calculate similarity score for a group of pairwise matches."""
+    if not matches:
+        return 1.0
+
+    return sum(match.similarity for match in matches) / len(matches)
+
+    

{redup-0.1.2 → redup-0.1.4}/src/redup.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redup
-Version: 0.1.2
+Version: 0.1.4
 Summary: Code duplication analyzer and refactoring planner for LLMs
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0

redup-0.1.2/src/redup/core/pipeline.py

@@ -1,183 +0,0 @@
-"""Pipeline — orchestrates scan → hash → match → group → plan."""
-
-from __future__ import annotations
-
-from redup.core.hasher import (
-    HashedBlock,
-    build_hash_index,
-    find_exact_duplicates,
-    find_structural_duplicates,
-)
-from redup.core.matcher import refine_structural_matches
-from redup.core.models import (
-    DuplicateFragment,
-    DuplicateGroup,
-    DuplicateType,
-    DuplicationMap,
-    ScanConfig,
-)
-from redup.core.planner import generate_suggestions
-from redup.core.scanner import CodeBlock, scan_project
-
-
-def _blocks_to_group(
-    group_id: str,
-    blocks: list[HashedBlock],
-    dup_type: DuplicateType,
-    similarity: float = 1.0,
-    normalized_hash: str = "",
-) -> DuplicateGroup:
-    """Convert a list of hashed blocks into a DuplicateGroup."""
-    # Deduplicate by file+line
-    seen: set[tuple[str, int]] = set()
-    fragments: list[DuplicateFragment] = []
-
-    for hb in blocks:
-        key = (hb.block.file, hb.block.line_start)
-        if key in seen:
-            continue
-        seen.add(key)
-        fragments.append(
-            DuplicateFragment(
-                file=hb.block.file,
-                line_start=hb.block.line_start,
-                line_end=hb.block.line_end,
-                text=hb.block.text,
-                function_name=hb.block.function_name,
-                class_name=hb.block.class_name,
-            )
-        )
-
-    if len(fragments) < 2:
-        return DuplicateGroup(id=group_id, duplicate_type=dup_type)
-
-    name = fragments[0].function_name if fragments[0].function_name else None
-
-    return DuplicateGroup(
-        id=group_id,
-        duplicate_type=dup_type,
-        fragments=fragments,
-        similarity_score=similarity,
-        normalized_hash=normalized_hash,
-        normalized_name=name,
-    )
-
-
-def _deduplicate_groups(groups: list[DuplicateGroup]) -> list[DuplicateGroup]:
-    """Remove groups that are subsets of larger groups."""
-    if not groups:
-        return groups
-
-    # Sort by impact (largest first)
-    sorted_groups = sorted(groups, key=lambda g: g.impact_score, reverse=True)
-    kept: list[DuplicateGroup] = []
-    seen_locations: set[tuple[str, int, int]] = set()
-
-    for group in sorted_groups:
-        if group.occurrences < 2:
-            continue
-
-        # Check if this group's fragments are already covered
-        locations = {
-            (f.file, f.line_start, f.line_end)
-            for f in group.fragments
-        }
-        new_locations = locations - seen_locations
-
-        if len(new_locations) >= 2:
-            kept.append(group)
-            seen_locations.update(locations)
-
-    return kept
-
-
-def analyze(
-    config: ScanConfig | None = None,
-    function_level_only: bool = False,
-) -> DuplicationMap:
-    """Run the full reDUP analysis pipeline.
-
-    Args:
-        config: Scan configuration. Defaults to current directory, .py files.
-        function_level_only: If True, only analyze function-level blocks
-            (skip sliding-window line blocks). Faster but misses inline duplicates.
-
-    Returns:
-        A DuplicationMap with all duplicate groups and refactoring suggestions.
-    """
-    if config is None:
-        config = ScanConfig()
-
-    # Phase 1: Scan
-    scanned_files, stats = scan_project(config)
-
-    # Collect blocks
-    all_blocks: list[CodeBlock] = []
-    for sf in scanned_files:
-        for block in sf.blocks:
-            if function_level_only and block.function_name is None:
-                continue
-            all_blocks.append(block)
-
-    # Phase 2: Hash
-    index = build_hash_index(all_blocks, min_lines=config.min_block_lines)
-
-    # Phase 3: Find candidates
-    groups: list[DuplicateGroup] = []
-    group_counter = 0
-
-    # 3a: Exact duplicates
-    exact_groups = find_exact_duplicates(index)
-    for h, blocks in exact_groups.items():
-        # Only keep function-level exact matches (skip noisy line blocks)
-        func_blocks = [b for b in blocks if b.block.function_name]
-        if len(func_blocks) >= 2:
-            group_counter += 1
-            g = _blocks_to_group(
-                group_id=f"E{group_counter:04d}",
-                blocks=func_blocks,
-                dup_type=DuplicateType.EXACT,
-                normalized_hash=h,
-            )
-            if g.occurrences >= 2:
-                groups.append(g)
-
-    # 3b: Structural duplicates (not already found as exact)
-    exact_hashes = set(exact_groups.keys())
-    structural_groups = find_structural_duplicates(index)
-    for h, blocks in structural_groups.items():
-        # Skip if all blocks are already in an exact group
-        if all(b.exact_hash in exact_hashes for b in blocks):
-            continue
-
-        func_blocks = [b for b in blocks if b.block.function_name]
-        if len(func_blocks) >= 2:
-            matches = refine_structural_matches(func_blocks, config.min_similarity)
-            if matches:
-                group_counter += 1
-                avg_sim = sum(m.similarity for m in matches) / len(matches)
-                g = _blocks_to_group(
-                    group_id=f"S{group_counter:04d}",
-                    blocks=func_blocks,
-                    dup_type=DuplicateType.STRUCTURAL,
-                    similarity=avg_sim,
-                    normalized_hash=h,
-                )
-                if g.occurrences >= 2:
-                    groups.append(g)
-
-    # Phase 4: Deduplicate overlapping groups
-    groups = _deduplicate_groups(groups)
-
-    # Phase 5: Build map and plan
-    dup_map = DuplicationMap(
-        project_path=str(config.root.resolve()),
-        config=config,
-        groups=groups,
-        stats=stats,
-    )
-
-    # Phase 6: Generate suggestions
-    dup_map.suggestions = generate_suggestions(dup_map)
-
-    return dup_map