redup 0.3.23__tar.gz → 0.3.24__tar.gz

{redup-0.3.23 → redup-0.3.24}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redup
-Version: 0.3.23
+Version: 0.3.24
 Summary: Code duplication analyzer and refactoring planner for LLMs
 Author-email: Tom Sapletta <tom@sapletta.com>
 License-Expression: Apache-2.0
@@ -84,7 +84,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.3.23-green.svg)](https://pypi.org/project/redup/)
+[![Version](https://img.shields.io/badge/version-0.3.24-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.3.23 → redup-0.3.24}/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.3.23-green.svg)](https://pypi.org/project/redup/)
+[![Version](https://img.shields.io/badge/version-0.3.24-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.3.23 → redup-0.3.24}/pyproject.toml

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

{redup-0.3.23 → redup-0.3.24}/src/redup/__init__.py

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

{redup-0.3.23 → redup-0.3.24}/src/redup/cli_app/config_builder.py

@@ -42,13 +42,13 @@ def build_config_with_file_support(
     if extensions is not None:
         scan_config.extensions = [e.strip() for e in extensions.split(',')]
     if min_lines is not None:
-        scan_config.min_lines = min_lines
+        scan_config.min_block_lines = min_lines
     if min_similarity is not None:
         scan_config.min_similarity = min_similarity
     if include_tests is not None:
         scan_config.include_tests = include_tests
     if functions_only:
-        scan_config.function_level_only = functions_only
+        scan_config.functions_only = functions_only
     
     # Add fuzzy support
     scan_config.fuzzy_enabled = fuzzy

{redup-0.3.23 → redup-0.3.24}/src/redup/cli_app/scan_commands.py

@@ -33,16 +33,16 @@ def scan_command(
     """Scan a project for code duplicates."""
     
     # Build configuration
-    if any([extensions, min_lines, min_similarity, include_tests, functions_only, parallel, max_workers, incremental, memory_cache, max_cache_mb]):
+    if any([extensions, min_lines, min_similarity, include_tests, functions_only, parallel, max_workers, incremental, memory_cache, max_cache_mb, fuzzy]):
         config = build_config_with_file_support(
             path, extensions, min_lines, min_similarity, include_tests,
-            parallel, max_workers, incremental, memory_cache, max_cache_mb, functions_only
+            parallel, max_workers, incremental, memory_cache, max_cache_mb, functions_only, fuzzy, fuzzy_threshold
         )
     else:
         config = build_config(path, extensions, min_lines, min_similarity, include_tests)
     
     # Print scan header
-    print_scan_header(path, config.extensions, config.min_lines, config.min_similarity)
+    print_scan_header(path, config.extensions, config.min_block_lines, config.min_similarity)
     
     # Run analysis
     if parallel and max_workers and max_workers > 1:
@@ -92,7 +92,7 @@ def check_command(
         path, extensions, min_lines, min_similarity, include_tests
     )
     
-    print_scan_header(path, config.extensions, config.min_lines, config.min_similarity)
+    print_scan_header(path, config.extensions, config.min_block_lines, config.min_similarity)
     
     dup_map = analyze(config)
     print_scan_summary(dup_map)

{redup-0.3.23 → redup-0.3.24}/src/redup/core/pipeline.py

@@ -16,7 +16,7 @@ from redup.core.hasher import (
 )
 from redup.core.lsh_matcher import find_near_duplicates
 from redup.core.matcher import MatchResult, refine_structural_matches
-from redup.core.parallel_scanner import scan_project_parallel
+from redup.core.scanner import scan_project, ScanStrategy
 from redup.core.models import (
     DuplicateFragment,
     DuplicateGroup,
@@ -26,10 +26,9 @@ from redup.core.models import (
     ScanStats,
 )
 from redup.core.planner import generate_suggestions
-from redup.core.scanner import CodeBlock, ScannedFile, scan_project
+from redup.core.scanner import CodeBlock, ScannedFile
 from redup.core.cache import HashCache, build_hash_index_with_cache
 from redup.core.lazy_grouper import find_all_duplicates_lazy, DuplicateGroupCollector
-from redup.core.memory_scanner import scan_project_memory_optimized, scan_project_parallel_memory_optimized
 
 
 def _blocks_to_group(
@@ -184,26 +183,29 @@ def analyze_optimized(
         # Phase 1: Optimized scanning with memory cache
         if config.parallel_workers and config.parallel_workers > 1:
             # Explicit worker count specified
-            if use_memory_cache:
-                scanned_files, stats = scan_project_parallel_memory_optimized(
-                    config, config.parallel_workers, max_cache_mb
-                )
-            else:
-                scanned_files, stats = _scan_phase_parallel(config, config.parallel_workers)
+            strategy = ScanStrategy(
+                parallel=True, 
+                max_workers=config.parallel_workers,
+                memory_cache=use_memory_cache,
+                max_cache_mb=max_cache_mb if use_memory_cache else 256
+            )
+            scanned_files, stats = scan_project(config, strategy, function_level_only=True)
         elif config.parallel_workers is None and (getattr(config, '_parallel_enabled', False) or config.parallel_workers is None):
             # Auto-detect CPU count when parallel_workers is None (default behavior)
             import multiprocessing as mp
             auto_workers = mp.cpu_count()
-            if use_memory_cache:
-                scanned_files, stats = scan_project_parallel_memory_optimized(
-                    config, auto_workers, max_cache_mb
-                )
-            else:
-                scanned_files, stats = _scan_phase_parallel(config, auto_workers)
+            strategy = ScanStrategy(
+                parallel=True,
+                max_workers=auto_workers,
+                memory_cache=use_memory_cache,
+                max_cache_mb=max_cache_mb if use_memory_cache else 256
+            )
+            scanned_files, stats = scan_project(config, strategy, function_level_only=True)
         elif use_memory_cache:
-            scanned_files, stats = scan_project_memory_optimized(config, max_cache_mb)
+            strategy = ScanStrategy(memory_cache=True, max_cache_mb=max_cache_mb)
+            scanned_files, stats = scan_project(config, strategy, function_level_only=True)
         else:
-            scanned_files, stats = _scan_phase(config)
+            scanned_files, stats = scan_project(config, function_level_only=True)
 
         # Phase 2: Process blocks
         all_blocks = _process_blocks(scanned_files, function_level_only)
@@ -260,15 +262,8 @@ def _scan_phase(config: ScanConfig, function_level_only: bool = False) -> tuple[
 
 def _scan_phase_parallel(config: ScanConfig, max_workers: int | None = None) -> tuple[list[ScannedFile], ScanStats]:
     """Phase 1: Scan project files in parallel."""
-    return scan_project_parallel(
-        root=config.root,
-        extensions=config.extensions,
-        exclude_patterns=config.exclude_patterns,
-        include_tests=config.include_tests,
-        function_level_only=True,  # Always function-level for parallel
-        max_file_size=config.max_file_size_kb,
-        max_workers=max_workers,
-    )
+    strategy = ScanStrategy(parallel=True, max_workers=max_workers or 4)
+    return scan_project(config, strategy, function_level_only=True)
 
 
 def _process_blocks(
@@ -552,12 +547,13 @@ def analyze_optimized(
 
     try:
         # Phase 1: Optimized Scan (parallel + memory cache)
-        if use_memory_cache:
-            scanned_files, stats = scan_project_parallel_memory_optimized(
-                config, max_workers=None, max_cache_mb=max_cache_mb
-            )
-        else:
-            scanned_files, stats = scan_project_parallel(config)
+        strategy = ScanStrategy(
+            parallel=True,
+            max_workers=None,  # Auto-detect
+            memory_cache=use_memory_cache,
+            max_cache_mb=max_cache_mb
+        )
+        scanned_files, stats = scan_project(config, strategy, function_level_only=True)
 
         # Phase 2: Process blocks
         all_blocks = _process_blocks(scanned_files, function_level_only)