from duplicate_code_tool import DuplicateCodeDetector

# Create detector with custom settings
detector = DuplicateCodeDetector(
    fail_threshold=80,      # Fail if any duplication >80%
    ignore_threshold=15,    # Ignore duplications <15%
    file_extensions=["py"], # Analyze Python files only
    only_code=True,         # Remove comments and docstrings
    show_loc=True,          # Include line count information
)

# Analyze a project
result = detector.analyze_project(
    project_path=".",
    exclude_patterns=["tests/", "docs/", ".git/"]
)

# Check results
if result.has_duplications():
    print(f"Found {len(result.reports)} files with duplications")
    
    # Get critical duplications
    critical = result.get_critical_duplications(threshold=50.0)
    for dup in critical:
        print(f"🚨 {dup.source_file} ↔ {dup.target_file} ({dup.similarity_percentage:.1f}%)")

from duplicate_code_tool import analyze_project_duplicates

# Simple project analysis
result = analyze_project_duplicates(
    project_path=".",
    threshold=20.0,
    exclude_patterns=["tests/", "docs/"]
)

print(f"Success: {result.is_success()}")
print(f"Duplications found: {result.has_duplications()}")

from duplicate_code_tool import DuplicateCodeDetector
import sys

def check_code_quality():
    """Quality gate for Flext CI/CD pipeline."""
    detector = DuplicateCodeDetector(
        fail_threshold=70,  # Fail if any duplication >70%
        ignore_threshold=20, # Ignore duplications <20%
        file_extensions=["py", "js", "ts"],
        only_code=True,
    )
    
    # Analyze Flext modules
    result = detector.detect_in_directories([
        "flext-core/src",
        "flext-ldap/src", 
        "flext-grpc/src",
    ], ignore_directories=["tests/", "__pycache__/"])
    
    if not result.is_success():
        print("❌ Code duplication threshold exceeded!")
        for dup in result.get_critical_duplications(50.0):
            print(f"   {dup.source_file} ↔ {dup.target_file}")
        sys.exit(1)
    
    print("✅ Code quality check passed!")

if __name__ == "__main__":
    check_code_quality()

#!/usr/bin/env python3
"""Pre-commit hook for duplicate code detection."""

import sys
from pathlib import Path
from duplicate_code_tool import DuplicateCodeDetector

def main():
    # Get staged files
    staged_files = sys.argv[1:] if len(sys.argv) > 1 else []
    
    if not staged_files:
        return 0
    
    # Filter Python files
    python_files = [f for f in staged_files if f.endswith('.py')]
    
    if not python_files:
        return 0
    
    # Check for duplications
    detector = DuplicateCodeDetector(
        fail_threshold=100,  # Don't fail, just warn
        ignore_threshold=30, # Only report significant duplications
        only_code=True,
    )
    
    result = detector.detect_in_files(python_files)
    
    if result.has_duplications():
        print("⚠️  Potential code duplications detected:")
        for dup in result.get_critical_duplications(40.0):
            print(f"   {dup.source_file} ↔ {dup.target_file} ({dup.similarity_percentage:.1f}%)")
        print("💡 Consider refactoring to reduce code duplication.")
    
    return 0

if __name__ == "__main__":
    sys.exit(main())

from duplicate_code_tool import DuplicateCodeDetector

detector = DuplicateCodeDetector(
    fail_threshold=60,
    ignore_threshold=25,
    file_extensions=["py", "js", "ts", "java"],
    only_code=True,
    show_loc=True,
)

# Analyze specific directories
result = detector.detect_in_directories(
    directories=["src/", "lib/"],
    ignore_directories=["tests/", "docs/", "node_modules/"],
    project_root_dir=".",
)

# Generate detailed report
if result.has_duplications():
    report_data = result.to_dict()
    
    # Save to JSON
    with open("duplication_report.json", "w") as f:
        f.write(result.to_json(indent=2))
    
    # Print summary
    print(f"📊 Analysis Summary:")
    print(f"   Files analyzed: {len(result.reports)}")
    print(f"   Critical duplications (>50%): {len(result.get_critical_duplications(50.0))}")
    print(f"   High duplications (>30%): {len(result.get_critical_duplications(30.0))}")

from duplicate_code_tool import analyze_project_duplicates
from pathlib import Path

def analyze_multiple_projects(project_paths: list[str]):
    """Analyze multiple projects and generate reports."""
    results = {}
    
    for project_path in project_paths:
        if Path(project_path).exists():
            print(f"🔍 Analyzing {project_path}...")
            
            result = analyze_project_duplicates(
                project_path=project_path,
                threshold=20.0,
                exclude_patterns=["tests/", "docs/", ".git/", "node_modules/"]
            )
            
            results[project_path] = result
            
            if result.has_duplications():
                print(f"   ⚠️  Found {len(result.reports)} files with duplications")
            else:
                print(f"   ✅ No significant duplications found")
    
    return results

# Usage
projects = ["flext-core", "flext-ldap", "flext-grpc"]
results = analyze_multiple_projects(projects)

detector = DuplicateCodeDetector(
    fail_threshold=80,
    ignore_threshold=15,
    file_extensions=["py"],
    only_code=True,
    show_loc=True,
)