Add duplicate file analysis for Android

Author: runningcode

src/launchpad/analyzers/android.py

@@ -4,7 +4,8 @@
 from datetime import datetime, timezone
 
 from ..artifacts import AAB, APK, AndroidArtifact, ZippedAAB, ZippedAPK
-from ..models.android import AndroidAnalysisResults, AndroidAppInfo
+from ..insights.common import DuplicateFilesInsight, InsightsInput
+from ..models.android import AndroidAnalysisResults, AndroidAppInfo, AndroidInsightResults
 from ..models.common import FileAnalysis, FileInfo
 from ..models.treemap import FILE_TYPE_TO_TREEMAP_TYPE, TreemapType
 from ..utils.file_utils import calculate_file_hash
@@ -21,6 +22,17 @@
 class AndroidAnalyzer:
     """Analyzer for Android apps (.apk, .aab files)."""
 
+    def __init__(
+        self,
+        skip_insights: bool = False,
+    ) -> None:
+        """Initialize the Android analyzer.
+
+        Args:
+            skip_insights: Skip insights generation for faster analysis
+        """
+        self.skip_insights = skip_insights
+
     def analyze(self, artifact: AndroidArtifact) -> AndroidAnalysisResults:
         manifest_dict = artifact.get_manifest().model_dump()
         start_time = time.time()
@@ -57,13 +69,26 @@ def analyze(self, artifact: AndroidArtifact) -> AndroidAnalysisResults:
 
         treemap = treemap_builder.build_file_treemap(file_analysis)
 
+        insights: AndroidInsightResults | None = None
+        if not self.skip_insights:
+            logger.info("Generating insights from analysis results")
+            insights_input = InsightsInput(
+                app_info=app_info,
+                file_analysis=file_analysis,
+                treemap=treemap,
+            )
+            insights = AndroidInsightResults(
+                duplicate_files=DuplicateFilesInsight().__call__(insights_input),
+            )
+
         analysis_duration = time.time() - start_time
         return AndroidAnalysisResults(
             generated_at=datetime.now(timezone.utc),
             analysis_duration=analysis_duration,
             app_info=app_info,
             treemap=treemap,
             file_analysis=file_analysis,
+            insights=insights,
         )
 
     def _get_file_analysis(self, apks: list[APK]) -> FileAnalysis:
@@ -104,14 +129,17 @@ def _get_file_analysis(self, apks: list[APK]) -> FileAnalysis:
                             merged_size,
                         )
 
+                        # For merged files, we need to recalculate the hash since the content
+                        # might be different across APKs. We'll use the hash of the current file.
+                        merged_file_hash = calculate_file_hash(file_path, algorithm="md5")
+
                         # Create new FileInfo with merged size
                         merged_file_info = FileInfo(
                             path=relative_path,
                             size=merged_size,
                             file_type=file_type,
                             treemap_type=treemap_type,
-                            # Intentionally igoring hash of merged file
-                            hash_md5="",
+                            hash_md5=merged_file_hash,
                         )
                         path_to_file_info[relative_path] = merged_file_info
                     else:

src/launchpad/cli.py

@@ -216,6 +216,10 @@ def android(
         else:
             _print_android_table_output(results, quiet)
 
+        if not quiet:
+            console.print(f"\n[bold green]✓[/bold green] Analysis completed in {duration:.2f}s")
+            _print_android_summary(results)
+
     except Exception as e:
         if verbose:
             console.print_exception()
@@ -376,6 +380,24 @@ def _print_file_analysis_table(file_analysis: FileAnalysis) -> None:
     console.print()
 
 
+def _print_android_summary(results: AndroidAnalysisResults) -> None:
+    """Print a brief summary of the analysis."""
+    file_analysis = results.file_analysis
+    insights = results.insights
+
+    console.print("\n[bold]Summary:[/bold]")
+    console.print(f"• App name: [cyan]{results.app_info.name}[/cyan]")
+    console.print(f"• Package name: [cyan]{results.app_info.package_name}[/cyan]")
+    console.print(f"• Total app size: [cyan]{_format_bytes(file_analysis.total_size)}[/cyan]")
+    console.print(f"• File count: [cyan]{file_analysis.file_count:,}[/cyan]")
+
+    if insights and insights.duplicate_files and insights.duplicate_files.total_savings > 0:
+        console.print(
+            f"• Potential savings from duplicates: "
+            f"[yellow]{_format_bytes(insights.duplicate_files.total_savings)}[/yellow]"
+        )
+
+
 def _print_apple_summary(results: AppleAnalysisResults) -> None:
     """Print a brief summary of the analysis."""
     file_analysis = results.file_analysis

src/launchpad/insights/common.py

@@ -4,23 +4,21 @@
 
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import Dict, List, Protocol, TypeVar
+from typing import Dict, List, Protocol, Sequence, TypeVar
 
-from launchpad.models.common import FileAnalysis, FileInfo
+from launchpad.models.common import BaseAppInfo, BaseBinaryAnalysis, FileAnalysis, FileInfo
 from launchpad.models.insights import DuplicateFilesInsightResult
 from launchpad.models.treemap import TreemapResults
 
-from ..models.apple import AppleAppInfo, MachOBinaryAnalysis
-
 T_co = TypeVar("T_co", covariant=True)
 
 
 @dataclass
 class InsightsInput:
-    app_info: AppleAppInfo
+    app_info: BaseAppInfo
     file_analysis: FileAnalysis
     treemap: TreemapResults | None
-    binary_analysis: List[MachOBinaryAnalysis]
+    binary_analysis: Sequence[BaseBinaryAnalysis] | None = None
 
 
 class Insight(Protocol[T_co]):

src/launchpad/models/android.py

@@ -1,6 +1,7 @@
-from pydantic import ConfigDict, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 from .common import BaseAnalysisResults, BaseAppInfo
+from .insights import DuplicateFilesInsightResult
 
 
 class AndroidAppInfo(BaseAppInfo):
@@ -9,8 +10,19 @@ class AndroidAppInfo(BaseAppInfo):
     package_name: str = Field(..., description="Android package name")
 
 
+class AndroidInsightResults(BaseModel):
+    """Collection of all insight results for Android."""
+
+    model_config = ConfigDict(frozen=True)
+
+    duplicate_files: DuplicateFilesInsightResult | None = Field(None, description="Duplicate files analysis")
+
+
 class AndroidAnalysisResults(BaseAnalysisResults):
     """Complete Android analysis results."""
 
     model_config = ConfigDict(frozen=True)
     app_info: AndroidAppInfo = Field(..., description="Android app information")
+    insights: AndroidInsightResults | None = Field(
+        description="Generated insights from the analysis",
+    )

tests/unit/test_android_analyzer.py

@@ -0,0 +1,86 @@
+"""Tests for Android analyzer with duplicate file detection."""
+
+from pathlib import Path
+
+import pytest
+
+from launchpad.analyzers.android import AndroidAnalyzer
+from launchpad.artifacts import ArtifactFactory
+
+
+@pytest.fixture
+def test_apk_path() -> Path:
+    return Path("tests/_fixtures/android/hn.apk")
+
+
+@pytest.fixture
+def android_analyzer() -> AndroidAnalyzer:
+    return AndroidAnalyzer()
+
+
+class TestAndroidAnalyzer:
+    def test_analyze_with_duplicate_detection(self, test_apk_path: Path, android_analyzer: AndroidAnalyzer) -> None:
+        """Test that Android analyzer includes duplicate file detection."""
+        artifact = ArtifactFactory.from_path(test_apk_path)
+        results = android_analyzer.analyze(artifact)
+
+        # Verify basic analysis results
+        assert results.app_info.name == "Hacker News"
+        assert results.app_info.package_name == "com.emergetools.hackernews"
+        assert results.file_analysis is not None
+        assert len(results.file_analysis.files) > 0
+
+        # Verify insights are generated
+        assert results.insights is not None
+        assert results.insights.duplicate_files is not None
+
+        # Verify duplicate files insight structure
+        duplicate_insight = results.insights.duplicate_files
+        assert hasattr(duplicate_insight, "files")
+        assert hasattr(duplicate_insight, "total_savings")
+        assert hasattr(duplicate_insight, "duplicate_count")
+        assert isinstance(duplicate_insight.total_savings, int)
+        assert isinstance(duplicate_insight.duplicate_count, int)
+        assert duplicate_insight.total_savings == 51709
+        assert duplicate_insight.duplicate_count == 52
+
+    def test_duplicate_files_have_hashes(self, test_apk_path: Path, android_analyzer: AndroidAnalyzer) -> None:
+        """Test that all files have MD5 hashes for duplicate detection."""
+        artifact = ArtifactFactory.from_path(test_apk_path)
+        results = android_analyzer.analyze(artifact)
+
+        for file_info in results.file_analysis.files:
+            assert file_info.hash_md5 is not None
+            assert len(file_info.hash_md5) > 0
+
+    def test_duplicate_detection_algorithm(self, test_apk_path: Path, android_analyzer: AndroidAnalyzer) -> None:
+        """Test that duplicate detection groups files by hash correctly."""
+        artifact = ArtifactFactory.from_path(test_apk_path)
+        results = android_analyzer.analyze(artifact)
+
+        # Group files by hash to verify the algorithm
+        files_by_hash = {}
+        for file_info in results.file_analysis.files:
+            if file_info.hash_md5 not in files_by_hash:
+                files_by_hash[file_info.hash_md5] = []
+            files_by_hash[file_info.hash_md5].append(file_info)
+
+        # Check that the duplicate detection found the same groups
+        duplicate_insight = results.insights.duplicate_files
+        expected_duplicate_files = []
+        expected_total_savings = 0
+
+        for file_list in files_by_hash.values():
+            if len(file_list) > 1:
+                # Calculate potential savings (all files except one)
+                total_file_size = sum(f.size for f in file_list)
+                savings = total_file_size - file_list[0].size
+
+                if savings > 0:
+                    # Add all files except the first one (which we'll keep)
+                    expected_duplicate_files.extend(file_list[1:])
+                    expected_total_savings += savings
+
+        # Verify the insight results match our manual calculation
+        assert len(duplicate_insight.files) == len(expected_duplicate_files)
+        assert duplicate_insight.total_savings == expected_total_savings