Merge pull request #8 from e2720pjk/opencode/issue4-20251224154752

Task 1: Connected fallback functions to analysis workflow,Task 2: Added integration tests,Task 3: Verified data flow

Author: e2720pjk

codewiki/src/be/dependency_analyzer/analysis/analysis_service.py

@@ -15,6 +15,10 @@
 from codewiki.src.be.dependency_analyzer.analysis.cloning import clone_repository, cleanup_repository, parse_github_url
 from codewiki.src.be.dependency_analyzer.models.analysis import AnalysisResult
 from codewiki.src.be.dependency_analyzer.models.core import Repository
+from codewiki.src.be.dependency_analyzer.utils.patterns import (
+    find_fallback_entry_points,
+    find_fallback_connectivity_files
+)
 
 
 logger = logging.getLogger(__name__)
@@ -63,55 +67,73 @@ def analyze_local_repository(
     ) -> Dict[str, Any]:
         """
         Analyze a local repository folder.
-        
+
         Args:
             repo_path: Path to local repository folder
             max_files: Maximum number of files to analyze
             max_entry_points: Maximum fallback entry points
             max_connectivity_files: Maximum fallback connectivity files
             languages: List of languages to include (e.g., ['python', 'javascript'])
-            
+
         Returns:
-            Dict with analysis results including nodes and relationships
+            Dict with analysis results including:
+                - nodes: Dict of function/call nodes
+                - relationships: List of call relationships
+                - entry_points: List of entry point files
+                - connectivity_files: List of high-connectivity files
+                - summary: Summary statistics including total_files, total_nodes,
+                          total_relationships, total_entry_points, total_connectivity_files
         """
         try:
             logger.debug(f"Analyzing local repository at {repo_path}")
-            
+
             # Validate file limits
             self._validate_file_limits(max_files, max_entry_points, max_connectivity_files)
-            
+
             # Get repo analyzer to find files
             repo_analyzer = RepoAnalyzer()
             structure_result = repo_analyzer.analyze_repository_structure(repo_path)
-            
+
             # Extract code files
             code_files = self.call_graph_analyzer.extract_code_files(structure_result["file_tree"])
-            
+
             # Filter by languages if specified
             if languages:
                 code_files = [f for f in code_files if f.get("language") in languages]
-            
+
             # Limit number of files
             if len(code_files) > max_files:
                 code_files = code_files[:max_files]
                 logger.debug(f"Limited analysis to {max_files} files")
-            
+
             logger.debug(f"Analyzing {len(code_files)} files")
-            
+
+            # Find fallback entry points
+            entry_points = find_fallback_entry_points(code_files, max_files=max_entry_points)
+            logger.debug(f"Found {len(entry_points)} fallback entry points")
+
+            # Find fallback connectivity files
+            connectivity_files = find_fallback_connectivity_files(code_files, max_files=max_connectivity_files)
+            logger.debug(f"Found {len(connectivity_files)} fallback connectivity files")
+
             # Analyze files
             enable_parallel = getattr(self.config, 'enable_parallel_processing', True)
             result = self.call_graph_analyzer.analyze_code_files(code_files, repo_path, enable_parallel)
-            
+
             return {
                 "nodes": result.get("functions", {}),
                 "relationships": result.get("relationships", []),
+                "entry_points": entry_points,
+                "connectivity_files": connectivity_files,
                 "summary": {
                     "total_files": len(code_files),
                     "total_nodes": len(result.get("functions", {})),
-                    "total_relationships": len(result.get("relationships", []))
+                    "total_relationships": len(result.get("relationships", [])),
+                    "total_entry_points": len(entry_points),
+                    "total_connectivity_files": len(connectivity_files)
                 }
             }
-            
+
         except Exception as e:
             logger.error(f"Local repository analysis failed: {str(e)}", exc_info=True)
             raise RuntimeError(f"Analysis failed: {str(e)}")

test/test_cli_file_limits.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""
+End-to-end CLI tests for file limit options.
+"""
+
+import pytest
+import tempfile
+from pathlib import Path
+from click.testing import CliRunner
+from codewiki.cli.main import cli
+from codewiki.cli.models.job import GenerationOptions
+
+
+class TestCLIFileLimits:
+    """End-to-end CLI tests for file limit options."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    def test_cli_accepts_max_files_option(self):
+        """Verify CLI accepts --max-files option."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            # Create a minimal test repository
+            temp_path = Path(temp_dir)
+            (temp_path / "main.py").write_text("def main(): pass\n")
+
+            result = self.runner.invoke(cli, ['generate', '--help'])
+            assert '--max-files' in result.output
+            assert '--max-entry-points' in result.output
+            assert '--max-connectivity-files' in result.output
+
+    def test_generation_options_has_file_limits(self):
+        """Verify GenerationOptions has file limit fields."""
+        options = GenerationOptions(
+            max_files=200,
+            max_entry_points=10,
+            max_connectivity_files=15
+        )
+        assert options.max_files == 200
+        assert options.max_entry_points == 10
+        assert options.max_connectivity_files == 15
+
+    def test_generation_options_defaults_match_configured(self):
+        """Verify default values match the configured defaults."""
+        options = GenerationOptions()
+        assert options.max_files == 100
+        assert options.max_entry_points == 5
+        assert options.max_connectivity_files == 10
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

test/test_file_limits.py

@@ -4,6 +4,10 @@
 """
 
 import pytest
+import tempfile
+import os
+from pathlib import Path
+from typing import List
 from codewiki.src.be.dependency_analyzer.analysis.analysis_service import AnalysisService
 
 
@@ -73,13 +77,203 @@ def test_edge_case_equal_values(self):
         """Test edge cases where values are equal."""
         # All equal values should be valid
         self.analysis_service._validate_file_limits(5, 5, 5)
-        
+
         # max_entry_points equals max_files should be valid
         self.analysis_service._validate_file_limits(10, 10, 5)
-        
+
         # max_connectivity_files equals max_files should be valid
         self.analysis_service._validate_file_limits(10, 5, 10)
 
 
+class TestFileLimitIntegration:
+    """Integration tests for actual file limiting behavior."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.analysis_service = AnalysisService()
+
+    def _create_test_files(self, temp_dir: Path, count: int, prefix: str = "file") -> List[Path]:
+        """Create test files in the given directory."""
+        files = []
+        for i in range(count):
+            file_path = temp_dir / f"{prefix}_{i}.py"
+            file_path.write_text(f"def func_{i}():\n    pass\n")
+            files.append(file_path)
+        return files
+
+    def test_max_files_actually_limits_files(self):
+        """Verify that max_files actually limits the number of files analyzed."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create 50 test files
+            self._create_test_files(temp_path, 50)
+
+            # Analyze with max_files=10
+            result = self.analysis_service.analyze_local_repository(
+                str(temp_path),
+                max_files=10,
+                max_entry_points=5,
+                max_connectivity_files=10
+            )
+
+            # Verify only 10 files were analyzed
+            assert result["summary"]["total_files"] == 10
+            assert len(result["nodes"]) <= 10
+
+    def test_max_entry_points_actually_limits_entry_points(self):
+        """Verify that max_entry_points actually limits entry points."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create potential entry point files
+            entry_point_names = ["main.py", "app.py", "index.py", "server.py", "start.py", "run.py"]
+            for name in entry_point_names:
+                (temp_path / name).write_text(f"# {name}\ndef main():\n    pass\n")
+
+            # Create additional non-entry point files
+            self._create_test_files(temp_path, 20, prefix="other")
+
+            # Analyze with max_entry_points=3
+            result = self.analysis_service.analyze_local_repository(
+                str(temp_path),
+                max_files=100,
+                max_entry_points=3,
+                max_connectivity_files=10
+            )
+
+            # Verify entry points are limited
+            assert len(result["entry_points"]) <= 3
+            assert result["summary"]["total_entry_points"] == len(result["entry_points"])
+
+            # Verify entry_points is a subset of analyzed files
+            entry_point_paths = {ep["path"] for ep in result["entry_points"]}
+            assert entry_point_paths
+
+    def test_max_connectivity_files_actually_limits_connectivity_files(self):
+        """Verify that max_connectivity_files actually limits connectivity files."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create source directories with files
+            for dir_name in ["src", "lib", "app", "core"]:
+                dir_path = temp_path / dir_name
+                dir_path.mkdir()
+                self._create_test_files(dir_path, 10, prefix=f"{dir_name}_file")
+
+            # Create some root files
+            self._create_test_files(temp_path, 5, prefix="root")
+
+            # Analyze with max_connectivity_files=10
+            result = self.analysis_service.analyze_local_repository(
+                str(temp_path),
+                max_files=100,
+                max_entry_points=5,
+                max_connectivity_files=10
+            )
+
+            # Verify connectivity files are limited
+            assert len(result["connectivity_files"]) <= 10
+            assert result["summary"]["total_connectivity_files"] == len(result["connectivity_files"])
+
+            # Verify connectivity_files are from source directories
+            connectivity_paths = [cf["path"] for cf in result["connectivity_files"]]
+            assert any("src/" in p or "lib/" in p or "app/" in p or "core/" in p for p in connectivity_paths)
+
+    def test_all_limits_respected_together(self):
+        """Verify that all three limits are respected when used together."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create entry point files
+            for name in ["main.py", "app.py", "index.py", "server.py", "start.py"]:
+                (temp_path / name).write_text(f"# {name}\ndef main():\n    pass\n")
+
+            # Create source directory files
+            for dir_name in ["src", "lib"]:
+                dir_path = temp_path / dir_name
+                dir_path.mkdir()
+                self._create_test_files(dir_path, 30, prefix=f"{dir_name}_file")
+
+            # Create additional files
+            self._create_test_files(temp_path, 50, prefix="other")
+
+            # Analyze with all three limits
+            result = self.analysis_service.analyze_local_repository(
+                str(temp_path),
+                max_files=50,
+                max_entry_points=5,
+                max_connectivity_files=10
+            )
+
+            # Verify all limits are respected
+            assert result["summary"]["total_files"] <= 50
+            assert len(result["entry_points"]) <= 5
+            assert len(result["connectivity_files"]) <= 10
+
+            # Verify entry_points and connectivity_files are subsets of analyzed files
+            all_analyzed_files = set()
+            for node in result["nodes"]:
+                if "file_path" in node:
+                    all_analyzed_files.add(node["file_path"])
+
+            # Verify validation rules (entry/connectivity counts don't exceed max_files)
+            assert len(result["entry_points"]) <= result["summary"]["total_files"]
+            assert len(result["connectivity_files"]) <= result["summary"]["total_files"]
+
+    @pytest.mark.parametrize("file_count,limit", [
+        (10, 10),
+        (50, 25),
+        (100, 50),
+    ])
+    def test_scalability_at_different_scales(self, file_count, limit):
+        """Test file limiting works with various project sizes."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create specified number of files
+            self._create_test_files(temp_path, file_count)
+
+            # Analyze with limit
+            result = self.analysis_service.analyze_local_repository(
+                str(temp_path),
+                max_files=limit
+            )
+
+            # Verify result matches expectation
+            if file_count >= limit:
+                assert result["summary"]["total_files"] == limit
+            else:
+                assert result["summary"]["total_files"] == file_count
+
+    def test_backward_compatibility_existing_fields(self):
+        """Verify backward compatibility: existing fields are present."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            # Create some test files
+            self._create_test_files(temp_path, 10)
+
+            # Analyze
+            result = self.analysis_service.analyze_local_repository(
+                str(temp_path),
+                max_files=10
+            )
+
+            # Verify existing fields are present
+            assert "nodes" in result
+            assert "relationships" in result
+            assert "summary" in result
+            assert "total_files" in result["summary"]
+            assert "total_nodes" in result["summary"]
+            assert "total_relationships" in result["summary"]
+
+            # Verify new fields are present
+            assert "entry_points" in result
+            assert "connectivity_files" in result
+            assert "total_entry_points" in result["summary"]
+            assert "total_connectivity_files" in result["summary"]
+
+
 if __name__ == "__main__":
     pytest.main([__file__])