crackerjack 0.33.0__py3-none-any.whl → 0.33.1__py3-none-any.whl

crackerjack/agents/test_creation_agent.py

@@ -28,15 +28,12 @@ class TestCreationAgent(SubAgent):
         }
 
     async def can_handle(self, issue: Issue) -> float:
-        """Enhanced confidence scoring based on issue complexity and expected impact."""
         if issue.type not in self.get_supported_types():
             return 0.0
 
         message_lower = issue.message.lower()
 
-        # High confidence for coverage improvement - key audit requirement
         if issue.type == IssueType.COVERAGE_IMPROVEMENT:
-            # Check for specific coverage improvement scenarios
             if any(
                 term in message_lower
                 for term in (
@@ -47,13 +44,12 @@ class TestCreationAgent(SubAgent):
                     "coverage requirement",
                 )
             ):
-                return 0.95  # Enhanced confidence for coverage issues
+                return 0.95
             return 0.9
 
         if issue.type == IssueType.TEST_ORGANIZATION:
             return self._check_test_organization_confidence(message_lower)
 
-        # Enhanced pattern matching for test creation needs
         perfect_score = self._check_perfect_test_creation_matches(message_lower)
         if perfect_score > 0:
             return perfect_score
@@ -62,12 +58,10 @@ class TestCreationAgent(SubAgent):
         if good_score > 0:
             return good_score
 
-        # Improved file path analysis
         file_path_score = self._check_file_path_test_indicators(issue.file_path)
         if file_path_score > 0:
             return file_path_score
 
-        # New: Check for untested functions specifically
         if self._indicates_untested_functions(message_lower):
             return 0.85
 
@@ -126,9 +120,7 @@ class TestCreationAgent(SubAgent):
         if not file_path:
             return 0.0
 
-        # Enhanced file path analysis
         if not self._has_corresponding_test(file_path):
-            # Higher confidence for core modules
             if any(
                 core_path in file_path
                 for core_path in ("/managers/", "/services/", "/core/", "/agents/")
@@ -138,7 +130,6 @@ class TestCreationAgent(SubAgent):
         return 0.0
 
     def _indicates_untested_functions(self, message_lower: str) -> bool:
-        """Check if message indicates untested functions."""
         return any(
             indicator in message_lower
             for indicator in (
@@ -152,10 +143,8 @@ class TestCreationAgent(SubAgent):
         )
 
     async def analyze_and_fix(self, issue: Issue) -> FixResult:
-        # Log the analysis
         self._log_analysis(issue)
 
-        # Apply fixes and create result
         return await self._apply_fixes_and_create_result(issue)
 
     def _log_analysis(self, issue: Issue) -> None:
@@ -174,7 +163,6 @@ class TestCreationAgent(SubAgent):
         self,
         issue: Issue,
     ) -> tuple[list[str], list[str]]:
-        # Apply all test creation fixes
         return await self._apply_all_test_creation_fixes(issue)
 
     async def _apply_all_test_creation_fixes(
@@ -184,7 +172,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str] = []
         files_modified: list[str] = []
 
-        # Apply different types of fixes
         fixes_applied, files_modified = await self._apply_all_fix_types(
             issue, fixes_applied, files_modified
         )
@@ -197,7 +184,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        # Apply all fix types sequentially
         return await self._apply_sequential_fixes(issue, fixes_applied, files_modified)
 
     async def _apply_sequential_fixes(
@@ -206,7 +192,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        # Apply all fix types sequentially
         return await self._apply_all_fix_types_sequentially(
             issue, fixes_applied, files_modified
         )
@@ -217,7 +202,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        # Apply all fix types sequentially
         return await self._apply_all_fix_types_in_sequence(
             issue, fixes_applied, files_modified
         )
@@ -228,7 +212,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        # Apply all fix types in sequence
         return await self._apply_fix_types_in_defined_order(
             issue, fixes_applied, files_modified
         )
@@ -239,7 +222,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        # Apply coverage based fixes
         (
             fixes_applied,
             files_modified,
@@ -247,7 +229,6 @@ class TestCreationAgent(SubAgent):
             fixes_applied, files_modified
         )
 
-        # Apply file specific fixes
         (
             fixes_applied,
             files_modified,
@@ -255,7 +236,6 @@ class TestCreationAgent(SubAgent):
             issue, fixes_applied, files_modified
         )
 
-        # Apply function specific fixes
         (
             fixes_applied,
             files_modified,
@@ -270,7 +250,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Apply coverage based fixes sequentially."""
         coverage_fixes, coverage_files = await self._apply_coverage_based_fixes()
         fixes_applied.extend(coverage_fixes)
         files_modified.extend(coverage_files)
@@ -282,7 +261,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Apply file specific fixes sequentially."""
         file_fixes, file_modified = await self._apply_file_specific_fixes(
             issue.file_path,
         )
@@ -295,7 +273,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Apply function specific fixes sequentially."""
         function_fixes, function_files = await self._apply_function_specific_fixes()
         fixes_applied.extend(function_fixes)
         files_modified.extend(function_files)
@@ -353,12 +330,10 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Handle low coverage by creating tests for uncovered modules."""
         self.log(
-            f"Coverage below threshold: {coverage_analysis['current_coverage']:.1%}",
+            f"Coverage below threshold: {coverage_analysis['current_coverage']: .1%}",
         )
 
-        # Process uncovered modules
         return await self._process_uncovered_modules_for_low_coverage(
             coverage_analysis["uncovered_modules"], fixes_applied, files_modified
         )
@@ -369,7 +344,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Process uncovered modules for low coverage scenario."""
         for module_path in uncovered_modules:
             test_fixes = await self._create_tests_for_module(module_path)
             fixes_applied.extend(test_fixes["fixes"])
@@ -383,8 +357,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Process uncovered modules to create tests."""
-        # Process each uncovered module
         return await self._process_each_uncovered_module(
             uncovered_modules, fixes_applied, files_modified
         )
@@ -395,8 +367,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Process each uncovered module individually."""
-        # Process all uncovered modules
         return await self._process_all_uncovered_modules(
             uncovered_modules, fixes_applied, files_modified
         )
@@ -407,7 +377,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Process all uncovered modules."""
         for module_path in uncovered_modules:
             fixes_applied, files_modified = await self._process_single_uncovered_module(
                 module_path, fixes_applied, files_modified
@@ -421,7 +390,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Process a single uncovered module."""
         test_fixes = await self._create_tests_for_module(module_path)
         fixes_applied.extend(test_fixes["fixes"])
         files_modified.extend(test_fixes["files"])
@@ -454,7 +422,6 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> tuple[list[str], list[str]]:
-        """Process untested functions to create tests."""
         for func_info in untested_functions[:5]:
             func_fixes = await self._create_test_for_function(func_info)
             fixes_applied.extend(func_fixes["fixes"])
@@ -467,10 +434,8 @@ class TestCreationAgent(SubAgent):
         fixes_applied: list[str],
         files_modified: list[str],
     ) -> FixResult:
-        """Enhanced result creation with detailed confidence scoring."""
         success = len(fixes_applied) > 0
 
-        # Calculate confidence based on the fixes applied
         confidence = self._calculate_confidence(success, fixes_applied, files_modified)
 
         return FixResult(
@@ -485,35 +450,28 @@ class TestCreationAgent(SubAgent):
     def _calculate_confidence(
         self, success: bool, fixes_applied: list[str], files_modified: list[str]
     ) -> float:
-        """Calculate confidence based on types of fixes applied."""
         if not success:
             return 0.0
 
-        # Enhanced confidence calculation based on types of fixes applied
-        confidence = 0.5  # Base confidence
+        confidence = 0.5
 
-        # Higher confidence based on quality of fixes
         test_file_fixes = [f for f in fixes_applied if "test file" in f.lower()]
         function_fixes = [f for f in fixes_applied if "function" in f.lower()]
         coverage_fixes = [f for f in fixes_applied if "coverage" in f.lower()]
 
-        # Boost confidence for comprehensive test creation
         if test_file_fixes:
-            confidence += 0.25  # Test file creation
+            confidence += 0.25
         if function_fixes:
-            confidence += 0.15  # Function-specific tests
+            confidence += 0.15
         if coverage_fixes:
-            confidence += 0.1  # Coverage improvements
+            confidence += 0.1
 
-        # Additional boost for multiple file creation (broader impact)
         if len(files_modified) > 1:
             confidence += 0.1
 
-        # Cap confidence at 0.95 for realistic assessment
         return min(confidence, 0.95)
 
     def _generate_recommendations(self, success: bool) -> list[str]:
-        """Generate recommendations based on the success of the operation."""
         if success:
             return [
                 "Generated comprehensive test suite",
@@ -526,13 +484,16 @@ class TestCreationAgent(SubAgent):
         ]
 
     def _get_enhanced_test_creation_recommendations(self) -> list[str]:
-        """Enhanced recommendations based on audit requirements."""
         return [
             "Run 'python -m crackerjack -t' to execute comprehensive coverage analysis",
-            "Focus on testing high-priority functions in managers/ services/ and core/ "
-            "modules",
-            "Implement parametrized tests (@pytest.mark.parametrize) for functions with "
-            "multiple arguments",
+            (
+                "Focus on testing high-priority functions in managers/ services/ "
+                "and core/ modules"
+            ),
+            (
+                "Implement parametrized tests (@pytest.mark.parametrize) "
+                "for functions with multiple arguments"
+            ),
             "Add edge case testing for boundary conditions and error scenarios",
             "Use fixtures for complex object instantiation and dependency injection",
             "Consider integration tests for modules with multiple classes/functions",
@@ -554,14 +515,11 @@ class TestCreationAgent(SubAgent):
         )
 
     async def _analyze_coverage(self) -> dict[str, Any]:
-        """Enhanced coverage analysis with detailed metrics and improvement tracking."""
         try:
-            # First try to get coverage from existing reports
             coverage_data = await self._get_existing_coverage_data()
             if coverage_data:
                 return coverage_data
 
-            # Run coverage analysis if no existing data
             returncode, _, stderr = await self._run_coverage_command()
 
             if returncode != 0:
@@ -574,9 +532,7 @@ class TestCreationAgent(SubAgent):
             return self._create_default_coverage_result()
 
     async def _get_existing_coverage_data(self) -> dict[str, Any] | None:
-        """Try to get coverage data from existing coverage reports."""
         try:
-            # Check for JSON coverage report
             json_report = self.context.project_path / "coverage.json"
             if json_report.exists():
                 content = self.context.get_file_content(json_report)
@@ -584,7 +540,6 @@ class TestCreationAgent(SubAgent):
                     coverage_json = json.loads(content)
                     return self._parse_coverage_json(coverage_json)
 
-            # Check for .coverage file
             coverage_file = self.context.project_path / ".coverage"
             if coverage_file.exists():
                 return await self._process_coverage_results_enhanced()
@@ -595,27 +550,24 @@ class TestCreationAgent(SubAgent):
         return None
 
     def _parse_coverage_json(self, coverage_json: dict[str, Any]) -> dict[str, Any]:
-        """Parse coverage JSON data into our format."""
         try:
             totals = coverage_json.get("totals", {})
             current_coverage = totals.get("percent_covered", 0) / 100.0
 
-            # Find uncovered modules
             uncovered_modules = []
             files = coverage_json.get("files", {})
 
             for file_path, file_data in files.items():
                 if file_data.get("summary", {}).get("percent_covered", 100) < 80:
-                    # Convert absolute path to relative
                     rel_path = str(
                         Path(file_path).relative_to(self.context.project_path)
                     )
                     uncovered_modules.append(rel_path)
 
             return {
-                "below_threshold": current_coverage < 0.8,  # 80% threshold
+                "below_threshold": current_coverage < 0.8,
                 "current_coverage": current_coverage,
-                "uncovered_modules": uncovered_modules[:15],  # Limit for performance
+                "uncovered_modules": uncovered_modules[:15],
                 "missing_lines": totals.get("num_statements", 0)
                 - totals.get("covered_lines", 0),
                 "total_lines": totals.get("num_statements", 0),
@@ -644,23 +596,20 @@ class TestCreationAgent(SubAgent):
         return self._create_default_coverage_result()
 
     async def _process_coverage_results_enhanced(self) -> dict[str, Any]:
-        """Enhanced coverage results processing with detailed analysis."""
         coverage_file = self.context.project_path / ".coverage"
         if not coverage_file.exists():
             return self._create_default_coverage_result()
 
-        # Get more detailed coverage analysis
         uncovered_modules = await self._find_uncovered_modules_enhanced()
         untested_functions = await self._find_untested_functions_enhanced()
 
-        # Estimate current coverage more accurately
         current_coverage = await self._estimate_current_coverage()
 
         return {
-            "below_threshold": current_coverage < 0.8,  # 80% threshold
+            "below_threshold": current_coverage < 0.8,
             "current_coverage": current_coverage,
-            "uncovered_modules": uncovered_modules[:15],  # Performance limit
-            "untested_functions": untested_functions[:20],  # Top priority functions
+            "uncovered_modules": uncovered_modules[:15],
+            "untested_functions": untested_functions[:20],
             "coverage_gaps": await self._identify_coverage_gaps(),
             "improvement_potential": self._calculate_improvement_potential(
                 len(uncovered_modules), len(untested_functions)
@@ -668,43 +617,38 @@ class TestCreationAgent(SubAgent):
         }
 
     async def _estimate_current_coverage(self) -> float:
-        """Estimate current coverage by analyzing test files vs source files."""
         try:
-            source_files = list(
+            source_files: list[Path] = list(
                 (self.context.project_path / "crackerjack").rglob("*.py")
             )
             source_files = [f for f in source_files if not f.name.startswith("test_")]
 
-            test_files = list((self.context.project_path / "tests").rglob("test_*.py"))
+            test_files: list[Path] = list(
+                (self.context.project_path / "tests").rglob("test_*.py")
+            )
 
             if not source_files:
                 return 0.0
 
-            # Simple heuristic: ratio of test files to source files
             coverage_ratio = len(test_files) / len(source_files)
 
-            # Adjust based on known coverage patterns
-            estimated_coverage = min(coverage_ratio * 0.6, 0.9)  # Cap at 90%
+            estimated_coverage = min(coverage_ratio * 0.6, 0.9)
 
             return estimated_coverage
 
         except Exception:
-            return 0.1  # Conservative estimate
+            return 0.1
 
     def _calculate_improvement_potential(
         self, uncovered_modules: int, untested_functions: int
     ) -> dict[str, Any]:
-        """Calculate potential coverage improvement from test generation."""
         if uncovered_modules == untested_functions == 0:
             return {"percentage_points": 0, "priority": "low"}
 
-        # Estimate improvement potential
-        module_improvement = uncovered_modules * 2.5  # Each module ~2.5% coverage
-        function_improvement = untested_functions * 0.8  # Each function ~0.8% coverage
+        module_improvement = uncovered_modules * 2.5
+        function_improvement = untested_functions * 0.8
 
-        total_potential = min(
-            module_improvement + function_improvement, 40
-        )  # Cap at 40%
+        total_potential = min(module_improvement + function_improvement, 40)
 
         priority = (
             "high"
@@ -729,7 +673,6 @@ class TestCreationAgent(SubAgent):
         }
 
     async def _find_uncovered_modules_enhanced(self) -> list[dict[str, Any]]:
-        """Enhanced uncovered modules detection with priority scoring."""
         uncovered: list[dict[str, Any]] = []
 
         package_dir = self.context.project_path / "crackerjack"
@@ -744,12 +687,10 @@ class TestCreationAgent(SubAgent):
                 module_info = await self._analyze_module_priority(py_file)
                 uncovered.append(module_info)
 
-        # Sort by priority (highest first)
         uncovered.sort(key=operator.itemgetter("priority_score"), reverse=True)
         return uncovered[:15]
 
     async def _analyze_module_priority(self, py_file: Path) -> dict[str, Any]:
-        """Analyze module to determine testing priority."""
         try:
             content = self.context.get_file_content(py_file) or ""
             ast.parse(content)
@@ -757,10 +698,8 @@ class TestCreationAgent(SubAgent):
             functions = await self._extract_functions_from_file(py_file)
             classes = await self._extract_classes_from_file(py_file)
 
-            # Calculate priority score
             priority_score = 0
 
-            # Core modules get higher priority
             rel_path = str(py_file.relative_to(self.context.project_path))
             if any(
                 core_path in rel_path
@@ -768,15 +707,12 @@ class TestCreationAgent(SubAgent):
             ):
                 priority_score += 10
 
-            # More functions/classes = higher priority
             priority_score += len(functions) * 2
             priority_score += len(classes) * 3
 
-            # Public API functions get higher priority
             public_functions = [f for f in functions if not f["name"].startswith("_")]
             priority_score += len(public_functions) * 2
 
-            # File size consideration (larger files need tests more)
             lines_count = len(content.split("\n"))
             if lines_count > 100:
                 priority_score += 5
@@ -808,7 +744,6 @@ class TestCreationAgent(SubAgent):
             }
 
     def _categorize_module(self, relative_path: str) -> str:
-        """Categorize module for test generation strategies."""
         if "managers/" in relative_path:
             return "manager"
         elif "services/" in relative_path:
@@ -824,7 +759,6 @@ class TestCreationAgent(SubAgent):
         return "utility"
 
     async def _find_untested_functions_enhanced(self) -> list[dict[str, Any]]:
-        """Enhanced untested function detection with detailed analysis."""
         untested: list[dict[str, Any]] = []
 
         package_dir = self.context.project_path / "crackerjack"
@@ -840,14 +774,12 @@ class TestCreationAgent(SubAgent):
             )
             untested.extend(file_untested)
 
-        # Sort by testing priority
         untested.sort(key=operator.itemgetter("testing_priority"), reverse=True)
         return untested[:20]
 
     async def _find_untested_functions_in_file_enhanced(
         self, py_file: Path
     ) -> list[dict[str, Any]]:
-        """Enhanced untested function detection with priority scoring."""
         untested: list[dict[str, Any]] = []
 
         try:
@@ -865,9 +797,7 @@ class TestCreationAgent(SubAgent):
     async def _analyze_function_testability(
         self, func: dict[str, Any], py_file: Path
     ) -> dict[str, Any]:
-        """Analyze function to determine testing priority and approach."""
         try:
-            # Basic function info
             func_info = {
                 "name": func["name"],
                 "file": str(py_file),
@@ -881,14 +811,11 @@ class TestCreationAgent(SubAgent):
                 "test_strategy": "basic",
             }
 
-            # Calculate testing priority
             priority = 0
 
-            # Public functions get higher priority
             if not func["name"].startswith("_"):
                 priority += 10
 
-            # Functions with multiple args are more complex
             arg_count = len(func.get("args", []))
             if arg_count > 3:
                 priority += 5
@@ -898,14 +825,12 @@ class TestCreationAgent(SubAgent):
                 priority += 2
                 func_info["complexity"] = "moderate"
 
-            # Core module functions get higher priority
             if any(
                 core_path in str(func_info["relative_file"])
                 for core_path in ("managers/", "services/", "core/")
             ):
                 priority += 8
 
-            # Async functions need special handling
             if func.get("is_async", False):
                 priority += 3
                 func_info["test_strategy"] = "async"
@@ -927,11 +852,9 @@ class TestCreationAgent(SubAgent):
             }
 
     async def _identify_coverage_gaps(self) -> list[dict[str, Any]]:
-        """Identify specific coverage gaps that can be addressed."""
-        gaps = []
+        gaps: list[dict[str, Any]] = []
 
         try:
-            # Find modules with partial test coverage
             package_dir = self.context.project_path / "crackerjack"
             tests_dir = self.context.project_path / "tests"
 
@@ -949,17 +872,16 @@ class TestCreationAgent(SubAgent):
         except Exception as e:
             self.log(f"Error identifying coverage gaps: {e}", "WARN")
 
-        return gaps[:10]  # Limit for performance
+        return gaps[:10]
 
     async def _analyze_existing_test_coverage(self, py_file: Path) -> dict[str, Any]:
-        """Analyze existing test coverage for a specific file."""
         try:
             test_file_path = await self._generate_test_file_path(py_file)
 
-            coverage_info = {
+            coverage_info: dict[str, Any] = {
                 "source_file": str(py_file.relative_to(self.context.project_path)),
                 "test_file": str(test_file_path) if test_file_path.exists() else None,
-                "has_gaps": True,  # Default assumption
+                "has_gaps": True,
                 "missing_test_types": [],
                 "coverage_score": 0,
             }
@@ -972,10 +894,8 @@ class TestCreationAgent(SubAgent):
                 ]
                 return coverage_info
 
-            # Analyze existing test file
             test_content = self.context.get_file_content(test_file_path) or ""
 
-            # Check for different test types
             missing_types = []
             if "def test_" not in test_content:
                 missing_types.append("basic")
@@ -1026,7 +946,6 @@ class TestCreationAgent(SubAgent):
         return False
 
     async def _create_tests_for_module(self, module_path: str) -> dict[str, list[str]]:
-        """Create tests for a module."""
         fixes: list[str] = []
         files: list[str] = []
 
@@ -1041,7 +960,6 @@ class TestCreationAgent(SubAgent):
         return {"fixes": fixes, "files": files}
 
     async def _generate_module_tests(self, module_path: str) -> dict[str, list[str]]:
-        """Generate tests for a module."""
         module_file = Path(module_path)
         if not await self._is_module_valid(module_file):
             return {"fixes": [], "files": []}
@@ -1055,7 +973,6 @@ class TestCreationAgent(SubAgent):
         return await self._create_test_artifacts(module_file, functions, classes)
 
     async def _is_module_valid(self, module_file: Path) -> bool:
-        """Check if the module file is valid."""
         return module_file.exists()
 
     async def _create_test_artifacts(
@@ -1064,7 +981,6 @@ class TestCreationAgent(SubAgent):
         functions: list[dict[str, Any]],
         classes: list[dict[str, Any]],
     ) -> dict[str, list[str]]:
-        """Create test artifacts for the module."""
         test_file_path = await self._generate_test_file_path(module_file)
         test_content = await self._generate_test_content(
             module_file,
@@ -1082,7 +998,6 @@ class TestCreationAgent(SubAgent):
         return {"fixes": [], "files": []}
 
     def _handle_test_creation_error(self, module_path: str, e: Exception) -> None:
-        """Handle errors during test creation."""
         self.log(f"Error creating tests for module {module_path}: {e}", "ERROR")
 
     async def _create_tests_for_file(self, file_path: str) -> dict[str, list[str]]:
@@ -1155,7 +1070,7 @@ class TestCreationAgent(SubAgent):
                     fixes.append(f"Added test for function {func_info['name']}")
                     files.append(str(test_file_path))
             else:
-                test_content = await self._generate_minimal_test_file(func_info)
+                test_content = await self._generate_function_test(func_info)
                 if self.context.write_file_content(test_file_path, test_content):
                     fixes.append(f"Created test file with test for {func_info['name']}")
                     files.append(str(test_file_path))
@@ -1172,7 +1087,7 @@ class TestCreationAgent(SubAgent):
         self,
         file_path: Path,
     ) -> list[dict[str, Any]]:
-        functions = []
+        functions: list[dict[str, Any]] = []
 
         try:
             content = self.context.get_file_content(file_path)
@@ -1188,7 +1103,6 @@ class TestCreationAgent(SubAgent):
         return functions
 
     def _parse_function_nodes(self, tree: ast.AST) -> list[dict[str, Any]]:
-        """Enhanced function parsing with async function support."""
         functions: list[dict[str, Any]] = []
 
         for node in ast.walk(tree):
@@ -1196,7 +1110,7 @@ class TestCreationAgent(SubAgent):
                 node, ast.FunctionDef | ast.AsyncFunctionDef
             ) and self._is_valid_function_node(node):
                 function_info = self._create_function_info(node)
-                # Add async detection
+
                 function_info["is_async"] = isinstance(node, ast.AsyncFunctionDef)
                 functions.append(function_info)
 
@@ -1205,13 +1119,11 @@ class TestCreationAgent(SubAgent):
     def _is_valid_function_node(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> bool:
-        """Enhanced validation for both sync and async functions."""
         return not node.name.startswith(("_", "test_"))
 
     def _create_function_info(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> dict[str, Any]:
-        """Enhanced function info creation with async support."""
         return {
             "name": node.name,
             "line": node.lineno,
@@ -1223,7 +1135,7 @@ class TestCreationAgent(SubAgent):
         }
 
     async def _extract_classes_from_file(self, file_path: Path) -> list[dict[str, Any]]:
-        classes = []
+        classes: list[dict[str, Any]] = []
 
         try:
             content = self.context.get_file_content(file_path)
@@ -1265,7 +1177,6 @@ class TestCreationAgent(SubAgent):
     def _get_function_signature(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> str:
-        """Enhanced function signature generation with async support."""
         args = [arg.arg for arg in node.args.args]
         prefix = "async " if isinstance(node, ast.AsyncFunctionDef) else ""
         return f"{prefix}{node.name}({', '.join(args)})"
@@ -1273,7 +1184,6 @@ class TestCreationAgent(SubAgent):
     def _get_return_annotation(
         self, node: ast.FunctionDef | ast.AsyncFunctionDef
     ) -> str:
-        """Enhanced return annotation extraction with async support."""
         if node.returns:
             return ast.unparse(node.returns) if (hasattr(ast, "unparse")) else "Any"
         return "Any"
@@ -1317,7 +1227,6 @@ class TestCreationAgent(SubAgent):
         functions: list[dict[str, Any]],
         classes: list[dict[str, Any]],
     ) -> str:
-        """Generate comprehensive test content with enhanced patterns."""
         test_params = self._prepare_test_generation_params(module_file)
         return await self._generate_all_test_types(test_params, functions, classes)
 
@@ -1327,11 +1236,9 @@ class TestCreationAgent(SubAgent):
         functions: list[dict[str, Any]],
         classes: list[dict[str, Any]],
     ) -> str:
-        """Generate comprehensive test content from prepared parameters."""
         return await self._generate_all_test_types(test_params, functions, classes)
 
     def _prepare_test_generation_params(self, module_file: Path) -> dict[str, Any]:
-        """Prepare parameters for test generation."""
         module_name = self._get_module_import_path(module_file)
         module_category = self._categorize_module(
             str(module_file.relative_to(self.context.project_path))
@@ -1348,15 +1255,12 @@ class TestCreationAgent(SubAgent):
         functions: list[dict[str, Any]],
         classes: list[dict[str, Any]],
     ) -> str:
-        """Generate all types of tests."""
-        # Generate header
         base_content = self._generate_enhanced_test_file_header(
             test_params["module_name"],
             test_params["module_file"],
             test_params["module_category"],
         )
 
-        # Generate different test sections
         function_tests = await self._generate_function_tests_content(
             functions, test_params["module_category"]
         )
@@ -1375,13 +1279,11 @@ class TestCreationAgent(SubAgent):
     async def _generate_function_tests_content(
         self, functions: list[dict[str, Any]], module_category: str
     ) -> str:
-        """Generate function tests content."""
         return await self._generate_enhanced_function_tests(functions, module_category)
 
     async def _generate_class_tests_content(
         self, classes: list[dict[str, Any]], module_category: str
     ) -> str:
-        """Generate class tests content."""
         return await self._generate_enhanced_class_tests(classes, module_category)
 
     async def _generate_integration_tests_content(
@@ -1391,7 +1293,6 @@ class TestCreationAgent(SubAgent):
         classes: list[dict[str, Any]],
         module_category: str,
     ) -> str:
-        """Generate integration tests content."""
         return await self._generate_integration_tests(
             module_file, functions, classes, module_category
         )
@@ -1399,9 +1300,6 @@ class TestCreationAgent(SubAgent):
     def _generate_enhanced_test_file_header(
         self, module_name: str, module_file: Path, module_category: str
     ) -> str:
-        """Generate enhanced test file header with appropriate imports based on
-        module type."""
-        # Determine imports based on module category
         imports = [
             "import pytest",
             "from pathlib import Path",
@@ -1421,13 +1319,10 @@ class TestCreationAgent(SubAgent):
 
         imports_str = "\n".join(imports)
 
-        # Add specific imports for the module
         try:
-            # Try to import specific classes/functions
             content = self.context.get_file_content(module_file) or ""
             tree = ast.parse(content)
 
-            # Extract importable items
             importable_items = []
             for node in ast.walk(tree):
                 if isinstance(node, ast.ClassDef) and not node.name.startswith("_"):
@@ -1449,43 +1344,28 @@ class TestCreationAgent(SubAgent):
 
         class_name = f"Test{module_file.stem.replace('_', '').title()}"
 
-        return f'''"""Tests for {module_name}.
-
-This module contains comprehensive tests for {module_name} including:
-- Basic functionality tests
-- Edge case validation
-- Error handling verification
-- Integration testing
-- Performance validation (where applicable)
-"""
-
-{imports_str}
-{specific_imports}
-
-
-class {class_name}:
-    """Comprehensive test suite for {module_name}."""
-
-    def test_module_imports_successfully(self):
-        """Test that the module can be imported without errors."""
-        import {module_name}
-        assert {module_name} is not None
-
-'''
-
-    async def _generate_minimal_test_file(self, func_info: dict[str, Any]) -> str:
-        file_path = Path(func_info["file"])
-        module_name = self._get_module_import_path(file_path)
-
-        return f'''"""Tests for {func_info["name"]} function."""
-
-import pytest
-
-from {module_name} import {func_info["name"]}
-
-
-{await self._generate_function_test(func_info)}
-'''
+        return (
+            f'"""{imports_str}\n'
+            f"{specific_imports}\n"
+            "\n"
+            "\n"
+            f"class {class_name}:\n"
+            f'    """Tests for {module_name}.\n'
+            "\n"
+            f"    This module contains comprehensive tests for {module_name}\n"
+            "    including:\n"
+            "    - Basic functionality tests\n"
+            "    - Edge case validation\n"
+            "    - Error handling verification\n"
+            "    - Integration testing\n"
+            "    - Performance validation (where applicable)\n"
+            '    """\n'
+            "\n"
+            "    def test_module_imports_successfully(self):\n"
+            '        """Test that the module can be imported without errors."""\n'
+            f"        import {module_name}\n"
+            f"        assert {module_name} is not None\n"
+        )
 
     def _get_module_import_path(self, file_path: Path) -> str:
         try:
@@ -1496,30 +1376,26 @@ from {module_name} import {func_info["name"]}
             return file_path.stem
 
     async def _generate_function_test(self, func_info: dict[str, Any]) -> str:
-        """Generate a test for a specific function."""
         func_name = func_info["name"]
         args = func_info.get("args", [])
 
-        # Generate basic test template
-        test_template = f'''def test_{func_name}_basic(self):
-    """Test basic functionality of {func_name}."""
+        test_template = f"""def test_{func_name}_basic(self):
+    \"\"\"Test basic functionality of {func_name}.\"\"\"
     try:
-        # Basic test - may need manual implementation for specific arguments
         result = {func_name}({self._generate_default_args(args)})
         assert result is not None or result is None
     except TypeError:
-        pytest.skip("Function requires specific arguments - manual implementation
-        needed")
+        pytest.skip(
+            "Function requires specific arguments - manual implementation needed"
+        )
     except Exception as e:
-        pytest.fail(f"Unexpected error in {func_name}: {{e}}")'''
+        pytest.fail(f"Unexpected error in {func_name}: {{e}}")"""
 
         return test_template
 
     async def _generate_enhanced_function_tests(
         self, functions: list[dict[str, Any]], module_category: str
     ) -> str:
-        """Generate enhanced test methods for functions with parametrization and
-        edge cases."""
         if not functions:
             return ""
 
@@ -1535,14 +1411,11 @@ from {module_name} import {func_info["name"]}
     async def _generate_all_tests_for_function(
         self, func: dict[str, Any], module_category: str
     ) -> list[str]:
-        """Generate all test types for a single function."""
         func_tests = []
 
-        # Always generate basic test
         basic_test = await self._generate_basic_function_test(func, module_category)
         func_tests.append(basic_test)
 
-        # Generate additional tests based on function characteristics
         additional_tests = await self._generate_conditional_tests_for_function(
             func, module_category
         )
@@ -1553,23 +1426,19 @@ from {module_name} import {func_info["name"]}
     async def _generate_conditional_tests_for_function(
         self, func: dict[str, Any], module_category: str
     ) -> list[str]:
-        """Generate conditional tests based on function characteristics."""
         tests = []
         args = func.get("args", [])
         func_name = func["name"]
 
-        # Generate parametrized test if function has multiple args
         if self._should_generate_parametrized_test(args):
             parametrized_test = await self._generate_parametrized_test(
                 func, module_category
             )
             tests.append(parametrized_test)
 
-        # Always generate error handling test
         error_test = await self._generate_error_handling_test(func, module_category)
         tests.append(error_test)
 
-        # Generate edge case tests for complex functions
         if self._should_generate_edge_case_test(args, func_name):
             edge_test = await self._generate_edge_case_test(func, module_category)
             tests.append(edge_test)
@@ -1577,11 +1446,9 @@ from {module_name} import {func_info["name"]}
         return tests
 
     def _should_generate_parametrized_test(self, args: list[str]) -> bool:
-        """Determine if parametrized test should be generated."""
         return len(args) > 1
 
     def _should_generate_edge_case_test(self, args: list[str], func_name: str) -> bool:
-        """Determine if edge case test should be generated."""
         has_multiple_args = len(args) > 2
         is_complex_function = any(
             hint in func_name.lower()
@@ -1592,7 +1459,6 @@ from {module_name} import {func_info["name"]}
     async def _generate_basic_function_test(
         self, func: dict[str, Any], module_category: str
     ) -> str:
-        """Generate basic functionality test for a function."""
         func_name = func["name"]
         args = func.get("args", [])
 
@@ -1602,7 +1468,6 @@ from {module_name} import {func_info["name"]}
     def _get_test_template_generator(
         self, module_category: str
     ) -> Callable[[str, list[str]], str]:
-        """Get the appropriate test template generator for the module category."""
         return {
             "agent": self._generate_agent_test_template,
             "service": self._generate_async_test_template,
@@ -1610,58 +1475,79 @@ from {module_name} import {func_info["name"]}
         }.get(module_category, self._generate_default_test_template)
 
     def _generate_agent_test_template(self, func_name: str, args: list[str]) -> str:
-        """Generate test template for agent functions."""
-        return f'''
-    def test_{func_name}_basic_functionality(self):
-        """Test basic functionality of {func_name}."""
-        # TODO: Implement specific test logic for {func_name}
-        # This is a placeholder test that should be customized
-        try:
-            result = {func_name}({self._generate_smart_default_args(args)})
-            assert result is not None or result is None
-        except (TypeError, NotImplementedError) as e:
-            pytest.skip(f"Function {func_name} requires manual implementation: {{e}}")
-        except Exception as e:
-            pytest.fail(f"Unexpected error in {func_name}: {{e}}")'''
+        template = (
+            "    def test_FUNC_NAME_basic_functionality(self):\n"
+            '        """Test basic functionality of FUNC_NAME."""\n'
+            "\n"
+            "\n"
+            "        try:\n"
+            "            result = FUNC_NAME(ARGS)\n"
+            "            assert result is not None or result is None\n"
+            "        except (TypeError, NotImplementedError) as e:\n"
+            + (
+                "            pytest.skip('Function FUNC_NAME requires manual "
+                "implementation: ' + str(e))\n"
+            )
+            + "        except Exception as e:\n"
+            "            pytest.fail('Unexpected error in FUNC_NAME: ' + str(e))"
+        )
+
+        return template.replace("FUNC_NAME", func_name).replace(
+            "ARGS", self._generate_smart_default_args(args)
+        )
 
     def _generate_async_test_template(self, func_name: str, args: list[str]) -> str:
-        """Generate test template for async service/manager functions."""
-        return f'''\n    @pytest.mark.asyncio\n    async def test_{func_name}_basic_functionality(self):
-        """Test basic functionality of {func_name}."""
-        # TODO: Implement specific test logic for {func_name}
-        # Consider mocking external dependencies
-        try:
-            if asyncio.iscoroutinefunction({func_name}):
-                result = await {func_name}({self._generate_smart_default_args(args)})
-            else:
-                result = {func_name}({self._generate_smart_default_args(args)})
-            assert result is not None or result is None
-        except (TypeError, NotImplementedError) as e:
-            pytest.skip(f"Function {func_name} requires manual implementation: {{e}}")
-        except Exception as e:
-            pytest.fail(f"Unexpected error in {func_name}: {{e}}")'''
+        template = (
+            " @pytest.mark.asyncio\n"
+            " async def test_FUNC_NAME_basic_functionality(self):\n"
+            '        """Test basic functionality of FUNC_NAME."""\n'
+            "\n"
+            "\n"
+            "        try:\n"
+            "            if asyncio.iscoroutinefunction(FUNC_NAME):\n"
+            "                result = await FUNC_NAME(ARGS)\n"
+            "            else:\n"
+            "                result = FUNC_NAME(ARGS)\n"
+            "            assert result is not None or result is None\n"
+            "        except (TypeError, NotImplementedError) as e:\n"
+            + (
+                "            pytest.skip('Function FUNC_NAME requires manual "
+                "implementation: ' + str(e))\n"
+            )
+            + "        except Exception as e:\n"
+            "            pytest.fail('Unexpected error in FUNC_NAME: ' + str(e))"
+        )
+
+        return template.replace("FUNC_NAME", func_name).replace(
+            "ARGS", self._generate_smart_default_args(args)
+        )
 
     def _generate_default_test_template(self, func_name: str, args: list[str]) -> str:
-        """Generate default test template for regular functions."""
-        return f'''
-    def test_{func_name}_basic_functionality(self):
-        """Test basic functionality of {func_name}."""
-        try:
-            result = {func_name}({self._generate_smart_default_args(args)})
-            assert result is not None or result is None
-        except (TypeError, NotImplementedError) as e:
-            pytest.skip(f"Function {func_name} requires manual implementation: {{e}}")
-        except Exception as e:
-            pytest.fail(f"Unexpected error in {func_name}: {{e}}")'''
+        template = (
+            "    def test_FUNC_NAME_basic_functionality(self):\n"
+            '        """Test basic functionality of FUNC_NAME."""\n'
+            "        try:\n"
+            "            result = FUNC_NAME(ARGS)\n"
+            "            assert result is not None or result is None\n"
+            "        except (TypeError, NotImplementedError) as e:\n"
+            + (
+                "            pytest.skip('Function FUNC_NAME requires manual "
+                "implementation: ' + str(e))\n"
+            )
+            + "        except Exception as e:\n"
+            "            pytest.fail('Unexpected error in FUNC_NAME: ' + str(e))"
+        )
+
+        return template.replace("FUNC_NAME", func_name).replace(
+            "ARGS", self._generate_smart_default_args(args)
+        )
 
     async def _generate_parametrized_test(
         self, func: dict[str, Any], module_category: str
     ) -> str:
-        """Generate parametrized test for functions with multiple arguments."""
         func_name = func["name"]
         args = func.get("args", [])
 
-        # Generate test parameters based on argument types
         test_cases = self._generate_test_parameters(args)
 
         if not test_cases:
@@ -1669,87 +1555,86 @@ from {module_name} import {func_info["name"]}
 
         parametrize_decorator = f"@pytest.mark.parametrize({test_cases})"
 
-        test_template = f'''
-    {parametrize_decorator}
-    def test_{func_name}_with_parameters(self, {
-            ", ".join(args) if len(args) <= 5 else "test_input"
-        }):
-        """Test {func_name} with various parameter combinations."""
-        try:
-            if len({args}) <= 5:
-                result = {func_name}({", ".join(args)})
-            else:
-                result = {func_name}(**test_input)
-            # Basic assertion - customize based on expected behavior
-            assert result is not None or result is None
-        except (TypeError, ValueError) as expected_error:
-            # Some parameter combinations may be invalid - this is expected
-            pass
-        except Exception as e:
-            pytest.fail(f"Unexpected error with parameters: {{e}}")'''
+        test_template = (
+            f"    {parametrize_decorator}\n"
+            f"    def test_{func_name}_with_parameters(self, "
+            f"{', '.join(args) if len(args) <= 5 else 'test_input'}):\n"
+            f'        """Test {func_name} with various parameter combinations."""\n'
+            "        try:\n"
+            f"            if len({args}) <= 5:\n"
+            f"                result = {func_name}({', '.join(args)})\n"
+            "            else:\n"
+            f"                result = {func_name}(**test_input)\n"
+            "\n"
+            "            assert result is not None or result is None\n"
+            "        except (TypeError, ValueError) as expected_error:\n"
+            "\n"
+            "            pass\n"
+            "        except Exception as e:\n"
+            '            pytest.fail(f"Unexpected error with parameters: {e}")'
+        )
 
         return test_template
 
     async def _generate_error_handling_test(
         self, func: dict[str, Any], module_category: str
     ) -> str:
-        """Generate error handling test for a function."""
         func_name = func["name"]
         args = func.get("args", [])
 
-        test_template = f'''
-    def test_{func_name}_error_handling(self):
-        """Test {func_name} error handling with invalid inputs."""
-        # Test with None values
-        with pytest.raises((TypeError, ValueError, AttributeError)):
-            {func_name}({self._generate_invalid_args(args)})
-
-        # Test with empty/invalid values where applicable
-        if len({args}) > 0:
-            with pytest.raises((TypeError, ValueError)):
-                {func_name}({self._generate_edge_case_args(args, "empty")})'''
+        test_template = (
+            f"    def test_{func_name}_error_handling(self):\n"
+            f'        """Test {func_name} error handling with invalid inputs."""\n'
+            "\n"
+            "        with pytest.raises((TypeError, ValueError, AttributeError)):\n"
+            f"            {func_name}({self._generate_invalid_args(args)})\n"
+            "\n"
+            "\n"
+            f"        if len({args}) > 0:\n"
+            "            with pytest.raises((TypeError, ValueError)):\n"
+            f"                {func_name}("
+            f"{self._generate_edge_case_args(args, 'empty')})"
+        )
 
         return test_template
 
     async def _generate_edge_case_test(
         self, func: dict[str, Any], module_category: str
     ) -> str:
-        """Generate edge case test for complex functions."""
         func_name = func["name"]
         args = func.get("args", [])
 
-        test_template = f'''
-    def test_{func_name}_edge_cases(self):
-        """Test {func_name} with edge case scenarios."""
-        # Test boundary conditions
-        edge_cases = [
-            {self._generate_edge_case_args(args, "boundary")},
-            {self._generate_edge_case_args(args, "extreme")},
-        ]
-
-        for edge_case in edge_cases:
-            try:
-                result = {func_name}(*edge_case)
-                # Verify the function handles edge cases gracefully
-                assert result is not None or result is None
-            except (ValueError, TypeError):
-                # Some edge cases may be invalid - that's acceptable
-                pass
-            except Exception as e:
-                pytest.fail(f"Unexpected error with edge case {{edge_case}}: {{e}}")'''
+        test_template = (
+            f"    def test_{func_name}_edge_cases(self):\n"
+            f'        """Test {func_name} with edge case scenarios."""\n'
+            "\n"
+            "        edge_cases = [\n"
+            f"            {self._generate_edge_case_args(args, 'boundary')},\n"
+            f"            {self._generate_edge_case_args(args, 'extreme')},\n"
+            "        ]\n"
+            "\n"
+            "        for edge_case in edge_cases:\n"
+            "            try:\n"
+            f"                result = {func_name}(*edge_case)\n"
+            "\n"
+            "                assert result is not None or result is None\n"
+            "            except (ValueError, TypeError):\n"
+            "\n"
+            "                pass\n"
+            "            except Exception as e:\n"
+            '                pytest.fail(f"Unexpected error with edge case {edge_case}: '
+            '{e}")'
+        )
 
         return test_template
 
     def _generate_test_parameters(self, args: list[str]) -> str:
-        """Generate test parameters for parametrized tests."""
-        if not args or len(args) > 5:  # Limit complexity
+        if not args or len(args) > 5:
             return ""
 
-        # Simple parameter generation
         param_names = ", ".join(f'"{arg}"' for arg in args)
         param_values = []
 
-        # Generate a few test cases
         for i in range(min(3, len(args))):
             test_case = []
             for arg in args:
@@ -1768,7 +1653,6 @@ from {module_name} import {func_info["name"]}
         return f"[{param_names}], [{', '.join(param_values)}]"
 
     def _generate_smart_default_args(self, args: list[str]) -> str:
-        """Generate smarter default arguments based on argument names."""
         if not args or args == ["self"]:
             return ""
 
@@ -1782,17 +1666,15 @@ from {module_name} import {func_info["name"]}
         return ", ".join(placeholders)
 
     def _filter_args(self, args: list[str]) -> list[str]:
-        """Filter out 'self' parameter from arguments."""
         return [arg for arg in args if arg != "self"]
 
     def _generate_placeholder_for_arg(self, arg: str) -> str:
-        """Generate a placeholder value for a single argument based on its name."""
         arg_lower = arg.lower()
 
         if self._is_path_arg(arg_lower):
             return 'Path("test_file.txt")'
         elif self._is_url_arg(arg_lower):
-            return '"https://example.com"'
+            return '"https: //example.com"'
         elif self._is_email_arg(arg_lower):
             return '"test@example.com"'
         elif self._is_id_arg(arg_lower):
@@ -1812,54 +1694,44 @@ from {module_name} import {func_info["name"]}
         return '"test"'
 
     def _is_path_arg(self, arg_lower: str) -> bool:
-        """Check if argument is path-related."""
         return any(term in arg_lower for term in ("path", "file"))
 
     def _is_url_arg(self, arg_lower: str) -> bool:
-        """Check if argument is URL-related."""
         return any(term in arg_lower for term in ("url", "uri"))
 
     def _is_email_arg(self, arg_lower: str) -> bool:
-        """Check if argument is email-related."""
         return any(term in arg_lower for term in ("email", "mail"))
 
     def _is_id_arg(self, arg_lower: str) -> bool:
-        """Check if argument is ID-related."""
         return any(term in arg_lower for term in ("id", "uuid"))
 
     def _is_name_arg(self, arg_lower: str) -> bool:
-        """Check if argument is name-related."""
         return any(term in arg_lower for term in ("name", "title"))
 
     def _is_numeric_arg(self, arg_lower: str) -> bool:
-        """Check if argument is numeric-related."""
         return any(term in arg_lower for term in ("count", "size", "number", "num"))
 
     def _is_boolean_arg(self, arg_lower: str) -> bool:
-        """Check if argument is boolean-related."""
         return any(term in arg_lower for term in ("enable", "flag", "is_", "has_"))
 
     def _is_text_arg(self, arg_lower: str) -> bool:
-        """Check if argument is text-related."""
         return any(term in arg_lower for term in ("data", "content", "text"))
 
     def _is_list_arg(self, arg_lower: str) -> bool:
-        """Check if argument is list-related."""
-        return any(term in arg_lower for term in ("list", "items"))
+        return any(term in arg_lower for term in ("list[t.Any]", "items"))
 
     def _is_dict_arg(self, arg_lower: str) -> bool:
-        """Check if argument is dict-related."""
-        return any(term in arg_lower for term in ("dict", "config", "options"))
+        return any(
+            term in arg_lower for term in ("dict[str, t.Any]", "config", "options")
+        )
 
     def _generate_invalid_args(self, args: list[str]) -> str:
-        """Generate invalid arguments for error testing."""
         filtered_args = [arg for arg in args if arg != "self"]
         if not filtered_args:
             return ""
         return ", ".join(["None"] * len(filtered_args))
 
     def _generate_edge_case_args(self, args: list[str], case_type: str) -> str:
-        """Generate edge case arguments."""
         filtered_args = self._filter_args(args)
         if not filtered_args:
             return ""
@@ -1872,24 +1744,22 @@ from {module_name} import {func_info["name"]}
     def _generate_placeholders_by_case_type(
         self, filtered_args: list[str], case_type: str
     ) -> list[str]:
-        """Generate placeholders based on case type."""
         if case_type == "empty":
             return self._generate_empty_case_placeholders(filtered_args)
         elif case_type == "boundary":
             return self._generate_boundary_case_placeholders(filtered_args)
-        # extreme
+
         return self._generate_extreme_case_placeholders(filtered_args)
 
     def _generate_empty_case_placeholders(self, filtered_args: list[str]) -> list[str]:
-        """Generate placeholders for empty case."""
         placeholders = []
         for arg in filtered_args:
             arg_lower = arg.lower()
             if any(term in arg_lower for term in ("str", "name", "text")):
                 placeholders.append('""')
-            elif any(term in arg_lower for term in ("list", "items")):
+            elif any(term in arg_lower for term in ("list[t.Any]", "items")):
                 placeholders.append("[]")
-            elif any(term in arg_lower for term in ("dict", "config")):
+            elif any(term in arg_lower for term in ("dict[str, t.Any]", "config")):
                 placeholders.append("{}")
             else:
                 placeholders.append("None")
@@ -1898,14 +1768,13 @@ from {module_name} import {func_info["name"]}
     def _generate_boundary_case_placeholders(
         self, filtered_args: list[str]
     ) -> list[str]:
-        """Generate placeholders for boundary case."""
         placeholders = []
         for arg in filtered_args:
             arg_lower = arg.lower()
             if any(term in arg_lower for term in ("count", "size", "number")):
                 placeholders.append("0")
             elif any(term in arg_lower for term in ("str", "name")):
-                placeholders.append('"x" * 1000')  # Very long string
+                placeholders.append('"x" * 1000')
             else:
                 placeholders.append("None")
         return placeholders
@@ -1913,7 +1782,6 @@ from {module_name} import {func_info["name"]}
     def _generate_extreme_case_placeholders(
         self, filtered_args: list[str]
     ) -> list[str]:
-        """Generate placeholders for extreme case."""
         placeholders = []
         for arg in filtered_args:
             arg_lower = arg.lower()
@@ -1926,8 +1794,6 @@ from {module_name} import {func_info["name"]}
     async def _generate_enhanced_class_tests(
         self, classes: list[dict[str, Any]], module_category: str
     ) -> str:
-        """Generate enhanced test methods for classes with fixtures and comprehensive
-        coverage."""
         if not classes:
             return ""
 
@@ -1941,7 +1807,6 @@ from {module_name} import {func_info["name"]}
     async def _generate_all_class_test_components(
         self, classes: list[dict[str, Any]], module_category: str
     ) -> dict[str, list[str]]:
-        """Generate all test components for classes."""
         fixtures = []
         test_methods = []
 
@@ -1957,17 +1822,14 @@ from {module_name} import {func_info["name"]}
     async def _generate_single_class_test_components(
         self, cls: dict[str, Any], module_category: str
     ) -> dict[str, list[str]]:
-        """Generate test components for a single class."""
         fixtures = []
         test_methods = []
         methods = cls.get("methods", [])
 
-        # Generate fixture for class instantiation
         fixture = await self._generate_class_fixture(cls, module_category)
         if fixture:
             fixtures.append(fixture)
 
-        # Generate core tests for the class
         core_tests = await self._generate_core_class_tests(
             cls, methods, module_category
         )
@@ -1978,22 +1840,18 @@ from {module_name} import {func_info["name"]}
     async def _generate_core_class_tests(
         self, cls: dict[str, Any], methods: list[str], module_category: str
     ) -> list[str]:
-        """Generate core tests for a class."""
         test_methods = []
 
-        # Basic class instantiation test
         instantiation_test = await self._generate_class_instantiation_test(
             cls, module_category
         )
         test_methods.append(instantiation_test)
 
-        # Generate tests for public methods (limit for performance)
         method_tests = await self._generate_method_tests(
             cls, methods[:5], module_category
         )
         test_methods.extend(method_tests)
 
-        # Generate property tests if applicable
         property_test = await self._generate_class_property_test(cls, module_category)
         if property_test:
             test_methods.append(property_test)
@@ -2003,7 +1861,6 @@ from {module_name} import {func_info["name"]}
     async def _generate_method_tests(
         self, cls: dict[str, Any], methods: list[str], module_category: str
     ) -> list[str]:
-        """Generate tests for class methods."""
         method_tests = []
         for method in methods:
             method_test = await self._generate_class_method_test(
@@ -2015,7 +1872,6 @@ from {module_name} import {func_info["name"]}
     def _combine_class_test_elements(
         self, fixtures: list[str], test_methods: list[str]
     ) -> str:
-        """Combine fixtures and test methods into a single string."""
         fixture_section = "\n".join(fixtures) if fixtures else ""
         test_section = "\n".join(test_methods)
         return fixture_section + test_section
@@ -2023,51 +1879,50 @@ from {module_name} import {func_info["name"]}
     async def _generate_class_fixture(
         self, cls: dict[str, Any], module_category: str
     ) -> str:
-        """Generate pytest fixture for class instantiation."""
         class_name = cls["name"]
 
         if module_category in ("service", "manager", "core"):
-            # These often require dependency injection
-            fixture_template = f'''
-    @pytest.fixture
-    def {class_name.lower()}_instance(self):
-        """Fixture to create {class_name} instance for testing."""
-        # TODO: Configure dependencies and mocks as needed
-        try:
-            return {class_name}()
-        except TypeError:
-            # If constructor requires arguments, mock them
-            with patch.object({class_name}, '__init__', return_value=None):
-                instance = {class_name}.__new__({class_name})
-                return instance'''
+            fixture_template = (
+                "    @pytest.fixture\n"
+                f"    def {class_name.lower()}_instance(self):\n"
+                f'        """Fixture to create {class_name} instance for testing."""\n'
+                "\n"
+                "        try:\n"
+                f"            return {class_name}()\n"
+                "        except TypeError:\n"
+                "\n"
+                f"            with patch.object({class_name}, '__init__', return_value=None):\n"
+                f"                instance = {class_name}.__new__({class_name})\n"
+                "                return instance"
+            )
 
         elif module_category == "agent":
-            # Agents typically require AgentContext
-            fixture_template = f'''
-    @pytest.fixture
-    def {class_name.lower()}_instance(self):
-        """Fixture to create {class_name} instance for testing."""
-        # Mock AgentContext for agent testing
-        mock_context = Mock(spec=AgentContext)
-        mock_context.project_path = Path("/test/project")
-        mock_context.get_file_content = Mock(return_value="# test content")
-        mock_context.write_file_content = Mock(return_value=True)
-
-        try:
-            return {class_name}(mock_context)
-        except Exception:
-            pytest.skip("Agent requires specific context configuration")'''
+            fixture_template = (
+                "    @pytest.fixture\n"
+                f"    def {class_name.lower()}_instance(self):\n"
+                f'        """Fixture to create {class_name} instance for testing."""\n'
+                "\n"
+                "        mock_context = Mock(spec=AgentContext)\n"
+                '        mock_context.project_path = Path("/test/project")\n'
+                '        mock_context.get_file_content = Mock(return_value="# test content")\n'
+                "        mock_context.write_file_content = Mock(return_value=True)\n"
+                "\n"
+                "        try:\n"
+                f"            return {class_name}(mock_context)\n"
+                "        except Exception:\n"
+                '            pytest.skip("Agent requires specific context configuration")'
+            )
 
         else:
-            # Simple fixture for other classes
-            fixture_template = f'''
-    @pytest.fixture
-    def {class_name.lower()}_instance(self):
-        """Fixture to create {class_name} instance for testing."""
-        try:
-            return {class_name}()
-        except TypeError:
-            pytest.skip("Class requires specific constructor arguments")'''
+            fixture_template = (
+                "    @pytest.fixture\n"
+                f"    def {class_name.lower()}_instance(self):\n"
+                f'        """Fixture to create {class_name} instance for testing."""\n'
+                "        try:\n"
+                f"            return {class_name}()\n"
+                "        except TypeError:\n"
+                '            pytest.skip("Class requires specific constructor arguments")'
+            )
 
         return fixture_template
 
@@ -2075,25 +1930,23 @@ from {module_name} import {func_info["name"]}
     async def _generate_class_instantiation_test(
         class_info: dict[str, Any], module_category: str
     ) -> str:
-        """Generate class instantiation test."""
         class_name = class_info["name"]
 
-        test_template = f'''
-    def test_{class_name.lower()}_instantiation(self, {class_name.lower()}_instance):
-        """Test successful instantiation of {class_name}."""
-        assert {class_name.lower()}_instance is not None
-        assert isinstance({class_name.lower()}_instance, {class_name})
-
-        # Test basic attributes exist
-        assert hasattr({class_name.lower()}_instance, '__class__')
-        assert {class_name.lower()}_instance.__class__.__name__ == "{class_name}"'''
+        test_template = (
+            f"    def test_{class_name.lower()}_instantiation(self, {class_name.lower()}_instance):\n"
+            f'        """Test successful instantiation of {class_name}."""\n'
+            f"        assert {class_name.lower()}_instance is not None\n"
+            f"        assert isinstance({class_name.lower()}_instance, {class_name})\n"
+            "\n"
+            f"        assert hasattr({class_name.lower()}_instance, '__class__')\n"
+            f'        assert {class_name.lower()}_instance.__class__.__name__ == "{class_name}"'
+        )
 
         return test_template
 
     async def _generate_class_method_test(
         self, cls: dict[str, Any], method_name: str, module_category: str
     ) -> str:
-        """Generate test for a class method."""
         class_name = cls["name"]
 
         if self._is_special_agent_method(module_category, method_name):
@@ -2103,14 +1956,12 @@ from {module_name} import {func_info["name"]}
         return self._generate_default_method_test(class_name, method_name)
 
     def _is_special_agent_method(self, module_category: str, method_name: str) -> bool:
-        """Check if this is a special agent method requiring custom test logic."""
         return module_category == "agent" and method_name in (
             "can_handle",
             "analyze_and_fix",
         )
 
     def _generate_agent_method_test(self, class_name: str, method_name: str) -> str:
-        """Generate test for special agent methods."""
         if method_name == "can_handle":
             return self._generate_can_handle_test(class_name)
         elif method_name == "analyze_and_fix":
@@ -2118,126 +1969,126 @@ from {module_name} import {func_info["name"]}
         return self._generate_generic_agent_method_test(class_name, method_name)
 
     def _generate_can_handle_test(self, class_name: str) -> str:
-        """Generate test for can_handle method."""
-        return f'''
-    @pytest.mark.asyncio
-    async def test_{class_name.lower()}_can_handle(self, {class_name.lower()}_instance):
-        """Test {class_name}.can_handle method."""
-        # Test with mock issue
-        mock_issue = Mock(spec=Issue)
-        mock_issue.type = IssueType.COVERAGE_IMPROVEMENT
-        mock_issue.message = "test coverage issue"
-        mock_issue.file_path = "/test/path.py"
-
-        result = await {class_name.lower()}_instance.can_handle(mock_issue)
-        assert isinstance(result, (int, float))
-        assert 0.0 <= result <= 1.0'''
+        return (
+            "    @pytest.mark.asyncio\n"
+            f"    async def test_{class_name.lower()}_can_handle(self, {class_name.lower()}_instance):\n"
+            f'        """Test {class_name}.can_handle method."""\n'
+            "\n"
+            "        mock_issue = Mock(spec=Issue)\n"
+            "        mock_issue.type = IssueType.COVERAGE_IMPROVEMENT\n"
+            '        mock_issue.message = "test coverage issue"\n'
+            '        mock_issue.file_path = "/test/path.py"\n'
+            "\n"
+            f"        result = await {class_name.lower()}_instance.can_handle(mock_issue)\n"
+            "        assert isinstance(result, (int, float))\n"
+            "        assert 0.0 <= result <= 1.0"
+        )
 
     def _generate_analyze_and_fix_test(self, class_name: str) -> str:
-        """Generate test for analyze_and_fix method."""
-        return f'''
-    @pytest.mark.asyncio
-    async def test_{class_name.lower()}_analyze_and_fix(self, {class_name.lower()}_instance):
-        """Test {class_name}.analyze_and_fix method."""
-        # Test with mock issue
-        mock_issue = Mock(spec=Issue)
-        mock_issue.type = IssueType.COVERAGE_IMPROVEMENT
-        mock_issue.message = "test coverage issue"
-        mock_issue.file_path = "/test/path.py"
-
-        result = await {class_name.lower()}_instance.analyze_and_fix(mock_issue)
-        assert isinstance(result, FixResult)
-        assert hasattr(result, 'success')
-        assert hasattr(result, 'confidence')'''
+        return (
+            "    @pytest.mark.asyncio\n"
+            f"    async def test_{class_name.lower()}_analyze_and_fix(self, {class_name.lower()}_instance):\n"
+            f'        """Test {class_name}.analyze_and_fix method."""\n'
+            "\n"
+            "        mock_issue = Mock(spec=Issue)\n"
+            "        mock_issue.type = IssueType.COVERAGE_IMPROVEMENT\n"
+            '        mock_issue.message = "test coverage issue"\n'
+            '        mock_issue.file_path = "/test/path.py"\n'
+            "\n"
+            f"        result = await {class_name.lower()}_instance.analyze_and_fix(mock_issue)\n"
+            "        assert isinstance(result, FixResult)\n"
+            "        assert hasattr(result, 'success')\n"
+            "        assert hasattr(result, 'confidence')"
+        )
 
     def _generate_generic_agent_method_test(
         self, class_name: str, method_name: str
     ) -> str:
-        """Generate test for generic agent methods."""
-        return f'''
-    @pytest.mark.asyncio
-    async def test_{class_name.lower()}_{method_name}(self, {class_name.lower()}_instance):
-        """Test {class_name}.{method_name} method."""
-        try:
-            method = getattr({class_name.lower()}_instance, "{method_name}", None)
-            assert method is not None, f"Method {method_name} should exist"
-
-            # Generic test for agent methods
-            if asyncio.iscoroutinefunction(method):
-                result = await method()
-            else:
-                result = method()
-
-            assert result is not None or result is None
-        except (TypeError, NotImplementedError):
-            pytest.skip(f"Method {method_name} requires specific arguments")
-        except Exception as e:
-            pytest.fail(f"Unexpected error in {method_name}: {{e}}")'''
+        return (
+            "    @pytest.mark.asyncio\n"
+            f"    async def test_{class_name.lower()}_{method_name}(self, {class_name.lower()}_instance):\n"
+            f'        """Test {class_name}.{method_name} method."""\n'
+            "        try:\n"
+            f"            method = getattr({class_name.lower()}_instance, "
+            f'"{method_name}", None)\n'
+            f"            assert method is not None, "
+            f'f"Method {method_name} should exist"\n'
+            "\n"
+            "            if asyncio.iscoroutinefunction(method):\n"
+            "                result = await method()\n"
+            "            else:\n"
+            "                result = method()\n"
+            "\n"
+            "            assert result is not None or result is None\n"
+            "        except (TypeError, NotImplementedError):\n"
+            f'            pytest.skip(f"Method {method_name} requires specific arguments")\n'
+            "        except Exception as e:\n"
+            f'            pytest.fail(f"Unexpected error in {method_name}: {{e}}")'
+        )
 
     def _generate_async_method_test(self, class_name: str, method_name: str) -> str:
-        """Generate test for async service/manager methods."""
-        return f'''
-    @pytest.mark.asyncio
-    async def test_{class_name.lower()}_{method_name}(self, {class_name.lower()}_instance):
-        """Test {class_name}.{method_name} method."""
-        try:
-            method = getattr({class_name.lower()}_instance, "{method_name}", None)
-            assert method is not None, f"Method {method_name} should exist"
-
-            # Test method call (may need arguments)
-            if asyncio.iscoroutinefunction(method):
-                result = await method()
-            else:
-                result = method()
-
-            # Basic assertion - customize based on expected behavior
-            assert result is not None or result is None
-
-        except (TypeError, NotImplementedError):
-            pytest.skip(f"Method {method_name} requires specific arguments or implementation")
-        except Exception as e:
-            pytest.fail(f"Unexpected error in {method_name}: {{e}}")'''
+        return (
+            "    @pytest.mark.asyncio\n"
+            f"    async def test_{class_name.lower()}_{method_name}(self, {class_name.lower()}_instance):\n"
+            f'        """Test {class_name}.{method_name} method."""\n'
+            "        try:\n"
+            f"            method = getattr({class_name.lower()}_instance, "
+            f'"{method_name}", None)\n'
+            f"            assert method is not None, "
+            f'f"Method {method_name} should exist"\n'
+            "\n"
+            "            if asyncio.iscoroutinefunction(method):\n"
+            "                result = await method()\n"
+            "            else:\n"
+            "                result = method()\n"
+            "\n"
+            "            assert result is not None or result is None\n"
+            "\n"
+            "        except (TypeError, NotImplementedError):\n"
+            f'            pytest.skip(f"Method {method_name} requires specific arguments or implementation")\n'
+            "        except Exception as e:\n"
+            f'            pytest.fail(f"Unexpected error in {method_name}: {{e}}")'
+        )
 
     def _generate_default_method_test(self, class_name: str, method_name: str) -> str:
-        """Generate test for default methods."""
-        return f'''
-    def test_{class_name.lower()}_{method_name}(self, {class_name.lower()}_instance):
-        """Test {class_name}.{method_name} method."""
-        try:
-            method = getattr({class_name.lower()}_instance, "{method_name}", None)
-            assert method is not None, f"Method {method_name} should exist"
-
-            # Test method call
-            result = method()
-            assert result is not None or result is None
-
-        except (TypeError, NotImplementedError):
-            pytest.skip(f"Method {method_name} requires specific arguments or implementation")
-        except Exception as e:
-            pytest.fail(f"Unexpected error in {method_name}: {{e}}")'''
+        return (
+            f"    def test_{class_name.lower()}_{method_name}(self, {class_name.lower()}_instance):\n"
+            f'        """Test {class_name}.{method_name} method."""\n'
+            "        try:\n"
+            f"            method = getattr({class_name.lower()}_instance, "
+            f'"{method_name}", None)\n'
+            f"            assert method is not None, "
+            f'f"Method {method_name} should exist"\n'
+            "\n"
+            "            result = method()\n"
+            "            assert result is not None or result is None\n"
+            "\n"
+            "        except (TypeError, NotImplementedError):\n"
+            f'            pytest.skip(f"Method {method_name} requires specific arguments or implementation")\n'
+            "        except Exception as e:\n"
+            f'            pytest.fail(f"Unexpected error in {method_name}: {{e}}")'
+        )
 
     async def _generate_class_property_test(
         self, cls: dict[str, Any], module_category: str
     ) -> str:
-        """Generate test for class properties."""
         class_name = cls["name"]
 
-        # Only generate property tests for certain module categories
         if module_category not in ("service", "manager", "agent"):
             return ""
 
-        test_template = f'''
-    def test_{class_name.lower()}_properties(self, {class_name.lower()}_instance):
-        """Test {class_name} properties and attributes."""
-        # Test that instance has expected structure
-        assert hasattr({class_name.lower()}_instance, '__dict__') or
-         hasattr({class_name.lower()}_instance, '__slots__')
-
-        # Test string representation
-        str_repr = str({class_name.lower()}_instance)
-        assert len(str_repr) > 0
-        assert "{class_name}" in str_repr or "{class_name.lower()}" in
-         str_repr.lower()'''
+        test_template = (
+            f"    def test_{class_name.lower()}_properties(self, {class_name.lower()}_instance):\n"
+            f'        """Test {class_name} properties and attributes."""\n'
+            "\n"
+            f"        assert hasattr({class_name.lower()}_instance, '__dict__') or \\\n"
+            f"         hasattr({class_name.lower()}_instance, '__slots__')\n"
+            "\n"
+            f"        str_repr = str({class_name.lower()}_instance)\n"
+            "        assert len(str_repr) > 0\n"
+            f'        assert "{class_name}" in str_repr or "{class_name.lower()}" in \\\n'
+            "         str_repr.lower()"
+        )
 
         return test_template
 
@@ -2248,52 +2099,44 @@ from {module_name} import {func_info["name"]}
         classes: list[dict[str, Any]],
         module_category: str,
     ) -> str:
-        """Generate integration tests for certain module types."""
         if module_category not in ("service", "manager", "core"):
             return ""
 
-        # Only generate integration tests for modules with sufficient complexity
         if len(functions) < 3 and len(classes) < 2:
             return ""
 
-        integration_tests = f'''
-
-    # Integration Tests
-    @pytest.mark.integration
-    def test_{module_file.stem}_integration(self):
-        """Integration test for {module_file.stem} module functionality."""
-        # TODO: Implement integration test scenarios
-        # Test interactions between classes and functions in this module
-        pytest.skip("Integration test needs manual implementation")
-
-    @pytest.mark.integration
-    @pytest.mark.asyncio
-    async def test_{module_file.stem}_async_integration(self):
-        """Async integration test for {module_file.stem} module."""
-        # TODO: Implement async integration scenarios
-        # Test async workflows and dependencies
-        pytest.skip("Async integration test needs manual implementation")
-
-    @pytest.mark.performance
-    def test_{module_file.stem}_performance(self):
-        """Basic performance test for {module_file.stem} module."""
-        # TODO: Add performance benchmarks if applicable
-        # Consider timing critical operations
-        pytest.skip("Performance test needs manual implementation")'''
+        integration_tests = (
+            "\n\n"
+            "    @pytest.mark.integration\n"
+            f"    def test_{module_file.stem}_integration(self):\n"
+            f'        """Integration test for {module_file.stem} module functionality."""\n'
+            "\n"
+            '        pytest.skip("Integration test needs manual implementation")\n'
+            "\n"
+            "    @pytest.mark.integration\n"
+            "    @pytest.mark.asyncio\n"
+            f"    async def test_{module_file.stem}_async_integration(self):\n"
+            f'        """Async integration test for {module_file.stem} module."""\n'
+            "\n"
+            '        pytest.skip("Async integration test needs manual implementation")\n'
+            "\n"
+            "    @pytest.mark.performance\n"
+            f"    def test_{module_file.stem}_performance(self):\n"
+            f'        """Basic performance test for {module_file.stem} module."""\n'
+            "\n"
+            '        pytest.skip("Performance test needs manual implementation")'
+        )
 
         return integration_tests
 
     def _generate_default_args(self, args: list[str]) -> str:
-        """Generate default arguments for function calls."""
         if not args or args == ["self"]:
             return ""
 
-        # Filter out 'self' parameter
         filtered_args = [arg for arg in args if arg != "self"]
         if not filtered_args:
             return ""
 
-        # Generate placeholder arguments
         placeholders = []
         for arg in filtered_args:
             if "path" in arg.lower():