redup 0.3.20__tar.gz → 0.3.22__tar.gz

{redup-0.3.20 → redup-0.3.22}/PKG-INFO

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

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

{redup-0.3.20 → redup-0.3.22}/src/redup/__init__.py

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

redup-0.3.22/src/redup/cli_app/config_builder.py

@@ -0,0 +1,51 @@
+"""Configuration builders for reDUP CLI."""
+
+from pathlib import Path
+from typing import Any
+
+from redup.core.config import config_to_scan_config, load_config
+from redup.core.models import ScanConfig
+
+
+def build_config(
+    path: Path,
+    extensions: str,
+    min_lines: int,
+    min_similarity: float,
+    include_tests: bool
+) -> ScanConfig:
+    """Build basic scan configuration."""
+    config = load_config()
+    return config_to_scan_config(config, path)
+
+
+def build_config_with_file_support(
+    path: Path,
+    extensions: Any,
+    min_lines: Any,
+    min_similarity: Any,
+    include_tests: Any,
+    parallel: bool = False,
+    max_workers: Any = None,
+    incremental: bool = False,
+    memory_cache: bool = False,
+    max_cache_mb: int = 512,
+    functions_only: bool = False
+) -> ScanConfig:
+    """Build scan configuration with advanced options."""
+    config = load_config()
+    scan_config = config_to_scan_config(config, path)
+    
+    # Override with CLI parameters if provided
+    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
+    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
+    
+    return scan_config

{redup-0.3.20 → redup-0.3.22}/src/redup/cli_app/main.py

@@ -13,15 +13,17 @@ import typer
 warnings.filterwarnings("ignore", category=SyntaxWarning)
 
 import redup  # noqa: E402
-from redup.core.config import config_to_scan_config, create_sample_redup_toml, load_config  # noqa: E402
+from redup.core.config import create_sample_redup_toml, load_config  # noqa: E402
 from redup.core.models import DuplicationMap, ScanConfig  # noqa: E402
-from redup.core.pipeline import analyze, analyze_parallel, analyze_optimized  # noqa: E402
-from redup.reporters.json_reporter import to_json  # noqa: E402
-from redup.reporters.markdown_reporter import to_markdown  # noqa: E402
-from redup.reporters.toon_reporter import to_toon  # noqa: E402
-from redup.reporters.yaml_reporter import to_yaml  # noqa: E402
-from redup.reporters.code2llm_reporter import export_code2llm, to_code2llm_context, to_code2llm_toon  # noqa: E402
-from redup.reporters.enhanced_reporter import EnhancedReporter  # noqa: E402
+from redup.core.differ import compare_scans, format_diff_result  # noqa: E402
+
+# Import refactored modules
+from redup.cli_app.config_builder import build_config, build_config_with_file_support  # noqa: E402
+from redup.cli_app.output_writer import write_output, write_results  # noqa: E402
+from redup.cli_app.scan_commands import (  # noqa: E402
+    scan_command, diff_command, check_command, config_command, info_command
+)
+from redup.cli_app.scan_helpers import print_scan_header, print_scan_summary  # noqa: E402
 
 app = typer.Typer(
     name="redup",
@@ -142,6 +144,160 @@ def _print_scan_summary(dup_map: DuplicationMap) -> None:
     typer.echo("")
 
 
+def _apply_fuzzy_similarity(dup_map: DuplicationMap, threshold: float) -> DuplicationMap:
+    """Apply fuzzy similarity detection to find similar components across all languages."""
+    validation = _validate_fuzzy_input(dup_map, threshold)
+    if not validation.is_valid:
+        typer.echo(validation.message)
+        return dup_map
+    
+    all_blocks = _extract_all_blocks(dup_map)
+    if not all_blocks:
+        typer.echo("🔍 No code blocks found for fuzzy analysis")
+        return dup_map
+    
+    typer.echo(f"🔍 Analyzing {len(all_blocks)} code blocks for universal fuzzy similarity...")
+    
+    html_css_blocks, other_blocks = _separate_blocks_by_type(all_blocks)
+    similar_pairs = _analyze_blocks_with_detectors(html_css_blocks, other_blocks, threshold)
+    
+    _report_fuzzy_results(similar_pairs)
+    return dup_map
+
+
+def _validate_fuzzy_input(dup_map: DuplicationMap, threshold: float) -> 'FuzzyValidationResult':
+    """Validate input parameters for fuzzy similarity analysis."""
+    from dataclasses import dataclass
+    
+    @dataclass
+    class FuzzyValidationResult:
+        is_valid: bool
+        message: str = ""
+    
+    if threshold <= 0 or threshold > 1:
+        return FuzzyValidationResult(False, "❌ Invalid threshold. Must be between 0 and 1.")
+    
+    if not dup_map.groups:
+        return FuzzyValidationResult(False, "❌ No duplicate groups found.")
+    
+    return FuzzyValidationResult(True)
+
+
+def _extract_all_blocks(dup_map: DuplicationMap) -> list:
+    """Extract all code blocks from duplicate fragments."""
+    from redup.core.scanner import CodeBlock
+    
+    all_blocks = []
+    for group in dup_map.groups:
+        for fragment in group.fragments:
+            # Create a CodeBlock from fragment data
+            block = CodeBlock(
+                file=fragment.file,
+                line_start=fragment.line_start,
+                line_end=fragment.line_end,
+                text=fragment.text,
+                function_name=fragment.function_name,
+                class_name=fragment.class_name
+            )
+            all_blocks.append(block)
+    return all_blocks
+
+
+def _separate_blocks_by_type(all_blocks: list) -> tuple[list, list]:
+    """Separate blocks into HTML/CSS and other language categories."""
+    html_css_blocks = [block for block in all_blocks 
+                      if Path(block.file).suffix.lower() in ['.html', '.htm', '.css', '.scss', '.sass', '.less']]
+    
+    other_blocks = [block for block in all_blocks if block not in html_css_blocks]
+    
+    return html_css_blocks, other_blocks
+
+
+def _analyze_blocks_with_detectors(html_css_blocks: list, other_blocks: list, threshold: float) -> list:
+    """Analyze blocks using appropriate fuzzy similarity detectors."""
+    similar_pairs = []
+    
+    # Analyze HTML/CSS with specialized detector
+    if html_css_blocks:
+        typer.echo(f"  📝 Analyzing {len(html_css_blocks)} HTML/CSS blocks...")
+        html_css_similar = _analyze_html_css_blocks(html_css_blocks, threshold)
+        similar_pairs.extend(html_css_similar)
+        typer.echo(f"    ✨ Found {len(html_css_similar)} similar HTML/CSS component pairs")
+    
+    # Analyze other languages with universal detector
+    if other_blocks:
+        typer.echo(f"  🔧 Analyzing {len(other_blocks)} blocks from other languages...")
+        universal_similar = _analyze_other_language_blocks(other_blocks, threshold)
+        similar_pairs.extend(universal_similar)
+        typer.echo(f"    ✨ Found {len(universal_similar)} similar component pairs from other languages")
+    
+    return similar_pairs
+
+
+def _analyze_html_css_blocks(html_css_blocks: list, threshold: float) -> list:
+    """Analyze HTML/CSS blocks using specialized fuzzy similarity detector."""
+    from redup.core.fuzzy_similarity import FuzzySimilarityDetector
+    
+    html_css_detector = FuzzySimilarityDetector(similarity_threshold=threshold)
+    return html_css_detector.find_similar_components(html_css_blocks)
+
+
+def _analyze_other_language_blocks(other_blocks: list, threshold: float) -> list:
+    """Analyze non-HTML/CSS blocks using universal fuzzy similarity detector."""
+    from redup.core.universal_fuzzy import UniversalFuzzyDetector
+    
+    universal_detector = UniversalFuzzyDetector(similarity_threshold=threshold)
+    return universal_detector.find_similar_components(other_blocks)
+
+
+def _report_fuzzy_results(similar_pairs: list) -> None:
+    """Report fuzzy similarity analysis results."""
+    if similar_pairs:
+        typer.echo(f"🎯 Total fuzzy similar components found: {len(similar_pairs)}")
+        
+        # Simplified reporting to reduce complexity
+        typer.echo(f"  📊 Language groups: {len(set(Path(b1.file).suffix + '+' + Path(b2.file).suffix for b1, b2, _ in similar_pairs))}")
+        
+        # Show top examples only
+        for block1, block2, similarity in similar_pairs[:5]:
+            typer.echo(f"    {block1.file} ↔ {block2.file}: {similarity:.2f}")
+        
+        if len(similar_pairs) > 5:
+            typer.echo(f"    ... and {len(similar_pairs) - 5} more")
+        
+        # Note: In production, you'd integrate these into DuplicationMap
+        # For now, we just report the findings
+        
+    else:
+        typer.echo("🔍 No fuzzy similar components found")
+
+
+def _report_similarity_by_groups(similar_pairs):
+    """Extracted function to reduce complexity."""
+    lang_groups = {}
+    for block1, block2, similarity in similar_pairs:
+        lang1 = Path(block1.file).suffix
+        lang2 = Path(block2.file).suffix
+        comp_type = "unknown"
+        
+        # Try to get component type
+        try:
+            from redup.core.universal_fuzzy import UniversalFuzzyExtractor
+            extractor = UniversalFuzzyExtractor()
+            sig1 = extractor.extract_universal_signature(block1)
+            if sig1:
+                comp_type = sig1.component_type
+        except:
+            pass
+        
+        group_key = f"{lang1}+{lang2}:{comp_type}"
+        if group_key not in lang_groups:
+            lang_groups[group_key] = []
+        lang_groups[group_key].append((block1, block2, similarity))
+    
+    return lang_groups
+
+
 def _write_results(
     dup_map: DuplicationMap,
     format: str,
@@ -247,6 +403,44 @@ def scan(
         "--parallel/--no-parallel",
         help="Use parallel scanning for large projects (default: disabled due to issues).",
     ),
+    max_workers: int | None = typer.Option(
+        None,
+        "--max-workers",
+        help="Maximum number of parallel workers.",
+    ),
+    incremental: bool = typer.Option(
+        False,
+        "--incremental",
+        help="Use incremental scanning with caching.",
+    ),
+    memory_cache: bool = typer.Option(
+        True,
+        "--memory-cache/--no-memory-cache",
+        help="Use memory cache for faster scanning.",
+    ),
+    max_cache_mb: int = typer.Option(
+        512,
+        "--max-cache-mb",
+        help="Maximum memory cache size in MB.",
+    ),
+    fuzzy: bool = typer.Option(
+        False,
+        "--fuzzy",
+        help="Enable fuzzy similarity detection.",
+    ),
+    fuzzy_threshold: float = typer.Option(
+        0.8,
+        "--fuzzy-threshold",
+        help="Fuzzy similarity threshold (0.0-1.0).",
+    ),
+) -> None:
+    """Scan a project for code duplicates."""
+    return scan_command(
+        path, format, output, extensions, min_lines, min_similarity,
+        include_tests, functions_only, parallel, max_workers,
+        incremental, memory_cache, max_cache_mb, fuzzy, fuzzy_threshold
+    )
+    ),
     max_workers: int = typer.Option(
         None,
         "--max-workers",
@@ -267,6 +461,16 @@ def scan(
         "--max-cache-mb",
         help="Maximum memory for file caching in MB (default: 512).",
     ),
+    fuzzy: bool = typer.Option(
+        False,
+        "--fuzzy/--no-fuzzy",
+        help="Enable fuzzy similarity detection for HTML/CSS components (default: disabled).",
+    ),
+    fuzzy_threshold: float = typer.Option(
+        0.8,
+        "--fuzzy-threshold",
+        help="Fuzzy similarity threshold (0.0-1.0, default: 0.8).",
+    ),
 ) -> None:
     """Scan a project for code duplicates and generate a refactoring map.
     
@@ -284,6 +488,10 @@ def scan(
             parallel, max_workers, incremental, memory_cache, max_cache_mb, functions_only
         )
 
+        # Add fuzzy options to config
+        config.fuzzy_enabled = fuzzy
+        config.fuzzy_threshold = fuzzy_threshold
+
         _print_scan_header(path, config.extensions, config.min_block_lines, config.min_similarity)
 
         # Choose analysis method
@@ -292,6 +500,10 @@ def scan(
         else:
             dup_map = analyze(config=config, function_level_only=functions_only)
 
+        # Apply fuzzy similarity detection if enabled
+        if fuzzy:
+            dup_map = _apply_fuzzy_similarity(dup_map, fuzzy_threshold)
+
         _print_scan_summary(dup_map)
         _write_results(dup_map, format, output, path)
         

redup-0.3.22/src/redup/cli_app/output_writer.py

@@ -0,0 +1,78 @@
+"""Output writers for reDUP CLI results."""
+
+from pathlib import Path
+from typing import Any
+
+from redup.core.models import DuplicationMap
+from redup.reporters.json_reporter import to_json
+from redup.reporters.markdown_reporter import to_markdown
+from redup.reporters.toon_reporter import to_toon
+from redup.reporters.yaml_reporter import to_yaml
+from redup.reporters.code2llm_reporter import export_code2llm, to_code2llm_context, to_code2llm_toon
+from redup.reporters.enhanced_reporter import EnhancedReporter
+
+
+def write_output(content: str, output: Path | None, suffix: str) -> None:
+    """Write content to file or stdout."""
+    import typer
+    
+    if output:
+        target = output if output.suffix else output / f"duplication.{suffix}"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content, encoding="utf-8")
+        typer.echo(f"  → {target}")
+    else:
+        typer.echo(content)
+
+
+def write_results(dup_map: DuplicationMap, format: str, output: Any, path: Path) -> None:
+    """Write analysis results in specified format."""
+    import typer
+    
+    if format == "json":
+        content = to_json(dup_map)
+        write_output(content, output, "json")
+    elif format == "yaml":
+        content = to_yaml(dup_map)
+        write_output(content, output, "yaml")
+    elif format == "toon":
+        content = to_toon(dup_map)
+        write_output(content, output, "toon")
+    elif format == "markdown":
+        content = to_markdown(dup_map)
+        write_output(content, output, "md")
+    elif format == "enhanced":
+        reporter = EnhancedReporter(dup_map)
+        content = reporter.generate_report()
+        write_output(content, output, "html")
+    elif format == "code2llm":
+        if output:
+            content = to_code2llm_context(dup_map)
+            write_output(content, output, "md")
+        else:
+            # For code2llm, create a directory with multiple files
+            export_code2llm(dup_map, output or path / "code2llm")
+    elif format == "all":
+        # Generate all formats
+        formats = {
+            "json": to_json(dup_map),
+            "yaml": to_yaml(dup_map),
+            "toon": to_toon(dup_map),
+            "markdown": to_markdown(dup_map),
+        }
+        
+        if output and output.is_dir():
+            for fmt, content in formats.items():
+                target = output / f"duplication.{fmt}"
+                target.write_text(content, encoding="utf-8")
+                typer.echo(f"  → {target}")
+        else:
+            # Write to separate files in the same directory
+            base_dir = output.parent if output else path
+            for fmt, content in formats.items():
+                target = base_dir / f"duplication.{fmt}"
+                target.write_text(content, encoding="utf-8")
+                typer.echo(f"  → {target}")
+    else:
+        typer.echo(f"❌ Unknown format: {format}", err=True)
+        raise typer.Exit(1)

redup-0.3.22/src/redup/cli_app/scan_commands.py

@@ -0,0 +1,163 @@
+"""Scan command implementations for reDUP CLI."""
+
+from pathlib import Path
+from typing import Any
+
+import typer
+
+from redup.core.config import create_sample_redup_toml
+from redup.core.models import DuplicationMap
+from redup.core.pipeline import analyze, analyze_parallel, analyze_optimized
+from redup.cli_app.config_builder import build_config, build_config_with_file_support
+from redup.cli_app.output_writer import write_output
+from redup.cli_app.scan_helpers import print_scan_header, print_scan_summary, apply_fuzzy_similarity
+
+
+def scan_command(
+    path: Path = typer.Argument(Path("."), help="Project root directory to scan.", exists=True, dir_okay=True, file_okay=False),
+    format: str = typer.Option("toon", "--format", "-f", help="Output format (json, yaml, toon, markdown, code2llm, all, enhanced)."),
+    output: Any = typer.Option(None, "--output", "-o", help="Output directory or file path. Defaults to stdout."),
+    extensions: Any = typer.Option(None, "--ext", "-e", help="Comma-separated file extensions to scan. Overrides config."),
+    min_lines: Any = typer.Option(None, "--min-lines", help="Minimum block size (lines). Overrides config."),
+    min_similarity: Any = typer.Option(None, "--min-sim", help="Minimum similarity score (0.0-1.0). Overrides config."),
+    include_tests: bool = typer.Option(False, "--include-tests", help="Include test files in analysis."),
+    functions_only: bool = typer.Option(False, "--functions-only", help="Only analyze function-level duplicates."),
+    parallel: bool = typer.Option(False, "--parallel", help="Use parallel processing for faster analysis."),
+    max_workers: Any = typer.Option(None, "--max-workers", help="Maximum number of parallel workers."),
+    incremental: bool = typer.Option(False, "--incremental", help="Use incremental scanning (cache-based)."),
+    memory_cache: bool = typer.Option(True, "--memory-cache/--no-memory-cache", help="Use memory cache for faster processing."),
+    max_cache_mb: int = typer.Option(512, "--max-cache-mb", help="Maximum memory cache size in MB."),
+    fuzzy: bool = typer.Option(False, "--fuzzy", help="Enable fuzzy similarity detection."),
+    fuzzy_threshold: float = typer.Option(0.8, "--fuzzy-threshold", help="Fuzzy similarity threshold (0.0-1.0)."),
+) -> None:
+    """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]):
+        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
+        )
+    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)
+    
+    # Run analysis
+    if parallel and max_workers and max_workers > 1:
+        dup_map = analyze_parallel(config, max_workers)
+    elif memory_cache:
+        dup_map = analyze_optimized(config, use_memory_cache=True, max_cache_mb=max_cache_mb)
+    else:
+        dup_map = analyze(config, function_level_only=functions_only)
+    
+    # Apply fuzzy similarity if requested
+    if fuzzy:
+        dup_map = apply_fuzzy_similarity(dup_map, fuzzy_threshold)
+    
+    # Print summary
+    print_scan_summary(dup_map)
+    
+    # Write results
+    from redup.cli_app.output_writer import write_results
+    write_results(dup_map, format, output, path)
+
+
+def diff_command(before: Path, after: Path) -> None:
+    """Compare two reDUP analysis results."""
+    from redup.core.differ import compare_scans, format_diff_result
+    
+    try:
+        diff = compare_scans(before, after)
+        result = format_diff_result(diff)
+        typer.echo(result)
+    except Exception as e:
+        typer.echo(f"❌ Error comparing scans: {e}", err=True)
+        raise typer.Exit(1)
+
+
+def check_command(
+    path: Path = typer.Argument(Path("."), help="Project root directory to check.", exists=True, dir_okay=True, file_okay=False),
+    max_groups: int = typer.Option(10, "--max-groups", help="Maximum duplicate groups to report."),
+    max_saved_lines: int = typer.Option(100, "--max-saved-lines", help="Maximum saved lines to report."),
+    extensions: Any = typer.Option(None, "--ext", "-e", help="Comma-separated file extensions to scan."),
+    min_lines: Any = typer.Option(None, "--min-lines", help="Minimum block size (lines)."),
+    min_similarity: Any = typer.Option(None, "--min-sim", help="Minimum similarity score (0.0-1.0)."),
+    include_tests: bool = typer.Option(False, "--include-tests", help="Include test files."),
+) -> None:
+    """Quick check for duplicates with summary report."""
+    
+    config = build_config_with_file_support(
+        path, extensions, min_lines, min_similarity, include_tests
+    )
+    
+    print_scan_header(path, config.extensions, config.min_lines, config.min_similarity)
+    
+    dup_map = analyze(config)
+    print_scan_summary(dup_map)
+    
+    # Show top duplicate groups
+    if dup_map.groups:
+        typer.echo(f"\n🎯 Top {min(max_groups, len(dup_map.groups))} duplicate groups:")
+        for i, group in enumerate(dup_map.sorted_by_impact()[:max_groups]):
+            if group.saved_lines_potential <= max_saved_lines:
+                break
+            typer.echo(f"  {i+1}. {group.id}: {group.occurrences} occurrences, {group.saved_lines_potential} lines recoverable")
+    else:
+        typer.echo("✅ No duplicates found!")
+
+
+def config_command(init: bool = typer.Option(False, "--init", help="Create sample redup.toml configuration."),
+                   show: bool = typer.Option(False, "--show", help="Show current configuration.")) -> None:
+    """Manage reDUP configuration."""
+    
+    if init:
+        config_path = Path("redup.toml")
+        if config_path.exists():
+            typer.echo("⚠️  redup.toml already exists. Overwrite? [y/N]", nl=False)
+            response = input().strip().lower()
+            if response != 'y':
+                typer.echo("Cancelled.")
+                return
+        
+        content = create_sample_redup_toml()
+        config_path.write_text(content, encoding="utf-8")
+        typer.echo(f"✅ Created sample configuration: {config_path}")
+    
+    elif show:
+        from redup.core.config import load_config
+        config = load_config()
+        typer.echo("Current configuration:")
+        typer.echo(f"  Extensions: {config.get('extensions', ['.py'])}")
+        typer.echo(f"  Min lines: {config.get('min_lines', 3)}")
+        typer.echo(f"  Min similarity: {config.get('min_similarity', 0.8)}")
+        typer.echo(f"  Include tests: {config.get('include_tests', False)}")
+    
+    else:
+        typer.echo("Use --init to create config or --show to display current config.")
+
+
+def info_command() -> None:
+    """Show reDUP version and system information."""
+    import redup
+    import sys
+    
+    typer.echo(f"reDUP version: {redup.__version__}")
+    typer.echo(f"Python version: {sys.version}")
+    typer.echo(f"Installation path: {Path(redup.__file__).parent}")
+    
+    # Check optional dependencies
+    deps = {
+        "tree-sitter": "tree_sitter",
+        "datasketch": "datasketch", 
+        "rapidfuzz": "rapidfuzz",
+    }
+    
+    typer.echo("\nOptional dependencies:")
+    for name, module in deps.items():
+        try:
+            __import__(module)
+            typer.echo(f"  ✅ {name}")
+        except ImportError:
+            typer.echo(f"  ❌ {name} (install with: pip install {name})")

redup-0.3.22/src/redup/cli_app/scan_helpers.py

@@ -0,0 +1,34 @@
+"""Helper functions for scan operations."""
+
+from pathlib import Path
+from typing import List
+
+import typer
+
+from redup.core.models import DuplicationMap
+from redup.cli_app.main import _apply_fuzzy_similarity
+
+
+def print_scan_header(path: Path, ext_list: List[str], min_lines: int, min_similarity: float) -> None:
+    """Print scan operation header."""
+    typer.echo(f"🔍 Scanning: {path}")
+    typer.echo(f"📁 Extensions: {', '.join(ext_list)}")
+    typer.echo(f"📏 Min lines: {min_lines}")
+    typer.echo(f"🎯 Min similarity: {min_similarity}")
+    typer.echo("")
+
+
+def print_scan_summary(dup_map: DuplicationMap) -> None:
+    """Print scan operation summary."""
+    typer.echo(f"📊 Scanned {dup_map.stats.files_scanned} files "
+               f"({dup_map.stats.total_lines} lines, "
+               f"{dup_map.stats.scan_time_ms:.0f}ms)")
+    typer.echo(f"Found {dup_map.total_groups} duplicate groups "
+               f"({dup_map.total_fragments} fragments, "
+               f"{dup_map.total_saved_lines} lines recoverable)")
+    typer.echo("")
+
+
+def apply_fuzzy_similarity(dup_map: DuplicationMap, threshold: float) -> DuplicationMap:
+    """Apply fuzzy similarity detection (wrapper for main function)."""
+    return _apply_fuzzy_similarity(dup_map, threshold)