redup 0.4.1__tar.gz → 0.4.3__tar.gz

{redup-0.4.1 → redup-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redup
-Version: 0.4.1
+Version: 0.4.3
 Summary: Code duplication analyzer and refactoring planner for LLMs
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -92,7 +92,7 @@ Dynamic: license-file
 [![PyPI](https://img.shields.io/pypi/v/redup)](https://pypi.org/project/redup/)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
-[![Version](https://img.shields.io/badge/version-0.4.1-green.svg)](https://pypi.org/project/redup/)
+[![Version](https://img.shields.io/badge/version-0.4.3-green.svg)](https://pypi.org/project/redup/)
 
 reDUP scans codebases for duplicated functions, blocks, and structural patterns — then builds a prioritized refactoring map that LLMs can consume to eliminate redundancy systematically.
 

{redup-0.4.1 → redup-0.4.3}/README.md

@@ -5,7 +5,7 @@
 [![PyPI](https://img.shields.io/pypi/v/redup)](https://pypi.org/project/redup/)
 [![License: Apache-2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
 [![Python](https://img.shields.io/badge/python-3.10%2B-blue.svg)](https://python.org)
-[![Version](https://img.shields.io/badge/version-0.4.1-green.svg)](https://pypi.org/project/redup/)
+[![Version](https://img.shields.io/badge/version-0.4.3-green.svg)](https://pypi.org/project/redup/)
 
 reDUP scans codebases for duplicated functions, blocks, and structural patterns — then builds a prioritized refactoring map that LLMs can consume to eliminate redundancy systematically.
 

{redup-0.4.1 → redup-0.4.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "redup"
-version = "0.4.1"
+version = "0.4.3"
 description = "Code duplication analyzer and refactoring planner for LLMs"
 readme = "README.md"
 license = "Apache-2.0"
@@ -90,6 +90,7 @@ dev = [
 
 [project.scripts]
 redup = "redup.cli_app.main:app"
+redup-mcp = "redup.mcp_server:run_server"
 
 [project.urls]
 Homepage = "https://github.com/semcod/redup"

{redup-0.4.1 → redup-0.4.3}/src/redup/__init__.py

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

{redup-0.4.1 → redup-0.4.3}/src/redup/core/scanner.py

@@ -140,22 +140,32 @@ def _should_exclude(path: Path, patterns: tuple[str, ...]) -> bool:
     return False  # Not excluded by any pattern
 
 
+def _project_relative_path(file_path: Path, project_root: Path) -> Path:
+    """Return a path relative to the project root when possible."""
+    try:
+        return file_path.relative_to(project_root)
+    except ValueError:
+        return file_path
+
+
 def _collect_files(config: ScanConfig) -> list[Path]:
     """Collect all files to scan based on configuration."""
     files = []
     
     for file_path in config.root.rglob("*"):
         if file_path.is_file():
+            relative_path = _project_relative_path(file_path, config.root)
+
             # Check extension
             if file_path.suffix not in config.extensions:
                 continue
             
             # Check exclusions
-            if _should_exclude(file_path, tuple(config.exclude_patterns)):
+            if _should_exclude(relative_path, tuple(config.exclude_patterns)):
                 continue
             
             # Check if test file
-            if not config.include_tests and _is_test_file(file_path):
+            if not config.include_tests and _is_test_file(relative_path):
                 continue
             
             # Check file size
@@ -458,6 +468,8 @@ def _should_process_file(
     max_file_size: int
 ) -> bool:
     """Check if file should be processed in parallel scan."""
+    relative_path = _project_relative_path(file_path, Path(project_root))
+
     # Check extension
     if file_path.suffix not in extensions:
         return False
@@ -467,11 +479,11 @@ def _should_process_file(
         "__pycache__", ".git", ".venv", "venv", "node_modules",
         ".tox", ".mypy_cache", ".pytest_cache", "*.egg-info", "dist", "build",
     ]
-    if _should_exclude(file_path, tuple(default_patterns)):
+    if _should_exclude(relative_path, tuple(default_patterns)):
         return False
     
     # Check if test file
-    if not include_tests and _is_test_file(file_path):
+    if not include_tests and _is_test_file(relative_path):
         return False
     
     # Check file size (convert KB to bytes)

redup-0.4.3/src/redup/core/utils/diff_helpers.py

@@ -0,0 +1,162 @@
+"""Helpers for comparing reDUP scan results."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Iterable
+
+from redup.core.models import DuplicateGroup
+
+
+def _group_files(group: DuplicateGroup) -> set[str]:
+    return {fragment.file for fragment in group.fragments}
+
+
+def _groups_match(group1: DuplicateGroup, group2: DuplicateGroup) -> bool:
+    """Check whether two duplicate groups likely represent the same finding."""
+    if group1.duplicate_type != group2.duplicate_type:
+        return False
+
+    if abs(group1.similarity_score - group2.similarity_score) > 0.1:
+        return False
+
+    files1 = _group_files(group1)
+    files2 = _group_files(group2)
+    if not files1 or not files2:
+        return False
+
+    overlap = len(files1.intersection(files2))
+    union = len(files1.union(files2))
+    if union == 0:
+        return False
+
+    return overlap / union >= 0.5
+
+
+@dataclass(slots=True)
+class _MatchResult:
+    before: DuplicateGroup
+    after: DuplicateGroup
+
+
+class GroupMatcher:
+    """Match duplicate groups between two scan results."""
+
+    def __init__(self, before_groups: dict[str, DuplicateGroup], after_groups: dict[str, DuplicateGroup]) -> None:
+        self.before_groups = before_groups
+        self.after_groups = after_groups
+        self._matches: list[_MatchResult] | None = None
+
+    def _ensure_matches(self) -> None:
+        if self._matches is not None:
+            return
+
+        matches: list[_MatchResult] = []
+        matched_before: set[str] = set()
+        matched_after: set[str] = set()
+
+        # First, prefer exact id matches when the groups are otherwise compatible.
+        for group_id, before_group in self.before_groups.items():
+            after_group = self.after_groups.get(group_id)
+            if after_group is None:
+                continue
+            if _groups_match(before_group, after_group):
+                matches.append(_MatchResult(before=before_group, after=after_group))
+                matched_before.add(group_id)
+                matched_after.add(group_id)
+
+        # Then, match remaining groups by structural similarity.
+        remaining_before = [
+            group
+            for group_id, group in self.before_groups.items()
+            if group_id not in matched_before
+        ]
+        remaining_after = [
+            group
+            for group_id, group in self.after_groups.items()
+            if group_id not in matched_after
+        ]
+
+        remaining_before.sort(key=lambda group: group.impact_score, reverse=True)
+        remaining_after.sort(key=lambda group: group.impact_score, reverse=True)
+
+        for before_group in remaining_before:
+            best_index: int | None = None
+            best_score = -1.0
+
+            for index, after_group in enumerate(remaining_after):
+                if after_group.id in matched_after:
+                    continue
+                if not _groups_match(before_group, after_group):
+                    continue
+
+                score = self._match_score(before_group, after_group)
+                if score > best_score:
+                    best_score = score
+                    best_index = index
+
+            if best_index is None:
+                continue
+
+            after_group = remaining_after[best_index]
+            matched_before.add(before_group.id)
+            matched_after.add(after_group.id)
+            matches.append(_MatchResult(before=before_group, after=after_group))
+
+        self._matches = matches
+
+    @staticmethod
+    def _match_score(before_group: DuplicateGroup, after_group: DuplicateGroup) -> float:
+        files_before = _group_files(before_group)
+        files_after = _group_files(after_group)
+        overlap = len(files_before.intersection(files_after))
+        union = len(files_before.union(files_after))
+        file_score = overlap / union if union else 0.0
+
+        score = file_score
+        if before_group.normalized_hash and before_group.normalized_hash == after_group.normalized_hash:
+            score += 1.0
+        if before_group.normalized_name and before_group.normalized_name == after_group.normalized_name:
+            score += 0.5
+        score += max(0.0, 1.0 - abs(before_group.similarity_score - after_group.similarity_score))
+        return score
+
+    def get_resolved_groups(self) -> list[DuplicateGroup]:
+        """Groups that disappeared between scans."""
+        self._ensure_matches()
+        matched_before = {match.before.id for match in self._matches or []}
+        return [group for group_id, group in self.before_groups.items() if group_id not in matched_before]
+
+    def get_new_groups(self) -> list[DuplicateGroup]:
+        """Groups that appeared in the later scan."""
+        self._ensure_matches()
+        matched_after = {match.after.id for match in self._matches or []}
+        return [group for group_id, group in self.after_groups.items() if group_id not in matched_after]
+
+    def get_unchanged_groups(self) -> list[DuplicateGroup]:
+        """Groups that are present in both scans."""
+        self._ensure_matches()
+        return [match.after for match in self._matches or []]
+
+
+class DiffCalculator:
+    """Aggregate statistics for scan diffs."""
+
+    @staticmethod
+    def calculate_diff_stats(
+        resolved_groups: Iterable[DuplicateGroup],
+        new_groups: Iterable[DuplicateGroup],
+        unchanged_groups: Iterable[DuplicateGroup],
+    ) -> dict[str, int]:
+        resolved_groups = list(resolved_groups)
+        new_groups = list(new_groups)
+        unchanged_groups = list(unchanged_groups)
+
+        return {
+            "resolved_count": len(resolved_groups),
+            "new_count": len(new_groups),
+            "unchanged_count": len(unchanged_groups),
+            "resolved_lines": sum(group.saved_lines_potential for group in resolved_groups),
+            "new_lines": sum(group.saved_lines_potential for group in new_groups),
+            "unchanged_lines": sum(group.saved_lines_potential for group in unchanged_groups),
+        }