def detect_errors(
     codebase: Codebase, context: CodebaseContext | None = None
 ) -> dict[str, Any]:
     """
     Detect errors in the codebase.
 
     Args:
         codebase: The codebase to analyze
         context: Optional context for the analysis
 
     Returns:
         A dictionary containing error detection results
     """
     detectors = [
         ParameterValidator(codebase, context),
         CallValidator(codebase, context),
         ReturnValidator(codebase, context),
         CodeQualityChecker(codebase, context),
     ]
 
     all_errors = []
+    detector_errors = {}
+    
     for detector in detectors:
-        all_errors.extend(detector.detect_errors())
+        try:
+            detector_errors = detector.detect_errors()
+            all_errors.extend(detector_errors)
+        except Exception as e:
+            all_errors.append(
+                DetectedError(
+                    category=ErrorCategory.CODE_QUALITY,
+                    severity=ErrorSeverity.ERROR,
+                    message=f"Error in detector {detector.__class__.__name__}: {str(e)}",
+                    file_path="",
+                    function_name="",
+                )
+            )

 def find_import_cycles(graph: nx.DiGraph) -> List[List[str]]:
     """
     Find cycles in the import graph.
 
     Args:
         graph: A directed graph representing import relationships
 
     Returns:
         A list of cycles, where each cycle is a list of module names
     """
-    # Find simple cycles in the graph
-    cycles = list(nx.simple_cycles(graph))
-    return cycles
+    try:
+        # Find simple cycles in the graph
+        cycles = list(nx.simple_cycles(graph))
+        return cycles
+    except nx.NetworkXNoCycle:
+        return []

 def convert_function_calls_to_kwargs(function: Function) -> None:
     """
     Convert all function calls within a function to use keyword arguments.
 
     Args:
         function: The function to modify
     """
     if not hasattr(function, "code_block"):
+        return
+
+    if not hasattr(function, "codebase"):
         return
 
     for call in function.code_block.function_calls:
         if not hasattr(call, "arguments"):
             continue
 
         # Find the called function
         called_function = None
         for func in function.codebase.functions:
             if func.name == call.name:
                 called_function = func
                 break
 
         if not called_function or not hasattr(called_function, "parameters"):
             continue
 
         # Convert positional arguments to keyword arguments
         for i, arg in enumerate(call.arguments):
             if not hasattr(arg, "name") or not arg.name:
                 if i < len(called_function.parameters):
                     param = called_function.parameters[i]
                     arg.name = param.name

 def get_call_depth(self, function_name: str) -> int:
     """
     Get the maximum call depth of a function.
 
     Args:
         function_name: The name of the function
 
     Returns:
         The maximum call depth of the function
     """
     visited = set()
 
     def dfs(node: str, depth: int) -> int:
         if node in visited:
             return 0
 
         visited.add(node)
 
         if not self.callees.get(node, set()):
             return depth
 
-        return max(dfs(callee, depth + 1) for callee in self.callees[node])
+        depths = [dfs(callee, depth + 1) for callee in self.callees[node]]
+        return max(depths) if depths else depth
 
     return dfs(function_name, 0)

 def analyze_types(
     codebase: Codebase, context: CodebaseContext | None = None
 ) -> dict[str, Any]:
     """
     Analyze types in the codebase.
 
     Args:
         codebase: The codebase to analyze
         context: Optional context for the analysis
 
     Returns:
         A dictionary containing type analysis results
     """
+    if not codebase or not hasattr(codebase, "functions"):
+        return {
+            "validation": {"total_errors": 0, "errors_by_issue": {}, "errors_by_file": {}},
+            "inference": {"inferred_types": {}},
+            "statistics": {
+                "functions_with_return_type": 0,
+                "functions_without_return_type": 0,
+                "parameters_with_type": 0,
+                "parameters_without_type": 0,
+                "variables_with_type": 0,
+                "variables_without_type": 0,
+            }
+        }
+        
     validator = TypeValidator(codebase, context)
     inference_engine = TypeInferenceEngine(codebase, context)
 
     # Validate types
     errors = validator.validate_types()
 
     # Infer types
     inferred_types = inference_engine.infer_types()

 def _validate_function_types(self) -> None:
     """Validate function parameter and return types."""
     for function in self.codebase.functions:
+        # Skip functions without required attributes
+        if not hasattr(function, "name") or not hasattr(function, "filepath"):
+            continue
+            
         # Check for missing return type annotation
         if (
             not hasattr(function, "return_type")
             or not function.return_type
         ):
             self.errors.append(
                 TypeValidationError(
                     issue=TypeIssue.MISSING_ANNOTATION,
                     message=(
                         f"Function '{function.name}' is missing a return "
                         "type annotation"
                     ),
                     file_path=function.filepath,
                     function_name=function.name,
                 )
             )

 def infer_types(self) -> dict[str, dict[str, str]]:
     """
     Infer types for variables in the codebase.
 
     Returns:
         A dictionary mapping function names to dictionaries mapping
         variable names to inferred types
     """
     self.inferred_types = {}
 
     for function in self.codebase.functions:
-        if not hasattr(function, "code_block"):
+        if not hasattr(function, "code_block") or not hasattr(function, "name"):
             continue
 
         self.inferred_types[function.name] = {}

 def get_call_depth(self, function_name: str) -> int:
     """
     Get the maximum call depth of a function.
 
     Args:
         function_name: The name of the function
 
     Returns:
         The maximum call depth of the function
     """
     visited = set()
+    path = set()
 
     def dfs(node: str, depth: int) -> int:
+        if node in path:  # Cycle detected
+            return depth
+            
         if node in visited:
             return 0
 
         visited.add(node)
+        path.add(node)
 
         if not self.callees.get(node, set()):
-            return depth
-
-        return max(dfs(callee, depth + 1) for callee in self.callees[node])
+            result = depth
+        else:
+            result = max(dfs(callee, depth + 1) for callee in self.callees[node])
+            
+        path.remove(node)
+        return result
 
     return dfs(function_name, 0)

 # Infer types from function calls
 for call in function.code_block.function_calls:
-    if hasattr(call, "target") and hasattr(call, "name"):
+    if (hasattr(call, "target") and hasattr(call, "name") and 
+        isinstance(call.target, str)):  # Ensure target is a valid string
         # Find the called function
         called_function = None
         for f in self.codebase.functions:
             if f.name == call.name:
                 called_function = f
                 break
 
         if called_function and hasattr(
             called_function, "return_type"
         ):
             self.inferred_types[function.name][
                 call.target
             ] = called_function.return_type

 def _validate_function_types(self) -> None:
     """Validate function parameter and return types."""
     for function in self.codebase.functions:
         # Check for missing return type annotation
         if (
             not hasattr(function, "return_type")
             or not function.return_type
         ):
+            file_path = function.filepath if hasattr(function, "filepath") else "unknown"
             self.errors.append(
                 TypeValidationError(
                     issue=TypeIssue.MISSING_ANNOTATION,
                     message=(
                         f"Function '{function.name}' is missing a return "
                         "type annotation"
                     ),
-                    file_path=function.filepath,
+                    file_path=file_path,
                     function_name=function.name,
                 )
             )

 def _check_complex_functions(self) -> None:
     """Check for overly complex functions."""
     for function in self.codebase.functions:
         if not hasattr(function, "code_block"):
             continue
 
         # Calculate cyclomatic complexity (simplified)
         complexity = 1  # Base complexity
-        for stmt in function.code_block.statements:
+        
+        def analyze_statement(stmt):
+            stmt_complexity = 0
             if hasattr(stmt, "type"):
                 if stmt.type in ["if_statement", "while_statement"]:
-                    complexity += 1
+                    stmt_complexity += 1
+                    # Count logical operators in conditions
+                    if hasattr(stmt, "condition") and isinstance(stmt.condition, str):
+                        stmt_complexity += stmt.condition.count(" and ") + stmt.condition.count(" or ")
                 elif stmt.type == "for_statement":
-                    complexity += 1
+                    stmt_complexity += 1
+            
+            # Check for nested statements
+            if hasattr(stmt, "body") and hasattr(stmt.body, "statements"):
+                for nested_stmt in stmt.body.statements:
+                    stmt_complexity += analyze_statement(nested_stmt)
+                    
+            return stmt_complexity
+        
+        for stmt in function.code_block.statements:
+            complexity += analyze_statement(stmt)

 # Check for inconsistent return types
 if hasattr(function, "code_block") and hasattr(
     function, "return_type"
 ):
     return_types = set()
     for stmt in function.code_block.statements:
         if (
             hasattr(stmt, "type")
             and stmt.type == "return_statement"
             and hasattr(stmt, "value")
+            and stmt.value is not None
             and hasattr(stmt.value, "type")
         ):
             return_types.add(stmt.value.type)
 
     if len(return_types) > 1:
         self.errors.append(
             TypeValidationError(
                 issue=TypeIssue.INCONSISTENT_RETURN_TYPE,
                 message=(
                     f"Function '{function.name}' has inconsistent "
                     f"return types: {', '.join(return_types)}"
                 ),
                 file_path=function.filepath,
                 function_name=function.name,
             )
         )

 def get_call_depth(self, function_name: str) -> int:
     """
     Get the maximum call depth of a function.
 
     Args:
         function_name: The name of the function
 
     Returns:
         The maximum call depth of the function
     """
     visited = set()
 
     def dfs(node: str, depth: int) -> int:
         if node in visited:
             return 0
 
         visited.add(node)
 
-        if not self.callees.get(node, set()):
+        callees = self.callees.get(node, set())
+        if not callees:
             return depth
 
-        return max(dfs(callee, depth + 1) for callee in self.callees[node])
+        return max((dfs(callee, depth + 1) for callee in callees), default=depth)
 
     return dfs(function_name, 0)

 def dfs(node: str) -> bool:
     if node in path:
         cycle = path[path.index(node):] + [node]
         self.errors.append(
             DetectedError(
                 category=ErrorCategory.CALL_ERROR,
                 severity=ErrorSeverity.WARNING,
                 message=(
                     "Circular dependency detected: "
                     f"{' -> '.join(cycle)}"
                 ),
                 file_path="",  # No specific file
                 function_name=node,
             )
         )
         return True
 
     if node in visited:
         return False
 
     visited.add(node)
     path.append(node)
 
     for callee in call_graph.get(node, set()):
-        if callee in call_graph and dfs(callee):
+        if dfs(callee):
             return True
 
     path.pop()
     return False

 # Group errors by issue type
 errors_by_issue: dict[str, list[dict[str, Any]]] = {}
 for error in errors:
     issue = error.issue.name
     if issue not in errors_by_issue:
         errors_by_issue[issue] = []
 
     errors_by_issue[issue].append(
         {
             "message": error.message,
             "file_path": error.file_path,
             "function_name": error.function_name,
             "line_number": error.line_number,
+            "symbol_name": error.symbol_name,
         }
     )

 def find_path(self, from_function: str, to_function: str) -> list[str]:
     """
     Find a path from one function to another in the call graph.
 
     Args:
         from_function: The starting function
         to_function: The target function
 
     Returns:
         A list of function names representing the path, or an empty list
         if no path exists
     """
     if from_function == to_function:
         return [from_function]
 
     visited = set()
     path = []
 
     def dfs(node: str) -> bool:
         if node == to_function:
             path.append(node)
             return True
 
         if node in visited:
             return False
 
         visited.add(node)
-        path.append(node)
 
         for callee in self.callees.get(node, set()):
             if dfs(callee):
+                path.append(node)
                 return True
 
-        path.pop()
         return False
 
     if dfs(from_function):
-        return path
+        return list(reversed(path))
     else:
         return []

 def infer_types(self) -> dict[str, dict[str, str]]:
     """
     Infer types for variables in the codebase.
 
     Returns:
         A dictionary mapping function names to dictionaries mapping
         variable names to inferred types
     """
     self.inferred_types = {}
 
     for function in self.codebase.functions:
         if not hasattr(function, "code_block"):
             continue
 
         self.inferred_types[function.name] = {}
 
         # Infer types from variable declarations with initializers
         for var in function.code_block.variable_declarations:
             if hasattr(var, "initializer") and hasattr(
                 var.initializer, "type"
             ):
                 self.inferred_types[function.name][
                     var.name
                 ] = var.initializer.type
 
         # Infer types from assignments
         for stmt in function.code_block.statements:
             if (
                 hasattr(stmt, "type")
                 and stmt.type == "assignment"
                 and hasattr(stmt, "left")
                 and hasattr(stmt, "right")
             ):
                 if hasattr(stmt.left, "name") and hasattr(
                     stmt.right, "type"
                 ):
                     self.inferred_types[function.name][
                         stmt.left.name
                     ] = stmt.right.type
 
         # Infer types from function calls
         for call in function.code_block.function_calls:
-            if hasattr(call, "target") and hasattr(call, "name"):
+            if hasattr(call, "target") and hasattr(call, "name") and call.target:
                 # Find the called function
                 called_function = None
                 for f in self.codebase.functions:
                     if f.name == call.name:
                         called_function = f
                         break
 
                 if called_function and hasattr(
                     called_function, "return_type"
                 ):
                     self.inferred_types[function.name][
                         call.target
                     ] = called_function.return_type

 def _check_parameter_types(self, function: Function) -> None:
     """
     Check for parameter type mismatches in a function.
 
     Args:
         function: The function to check
     """
     if not hasattr(function, "parameters") or not function.parameters:
         return
 
     # Check for parameters with type annotations
     for param in function.parameters:
         if (
             not hasattr(param, "type_annotation")
             or not param.type_annotation
         ):
             continue
 
         # Check for calls to this function
         for caller in self.codebase.functions:
             if not hasattr(caller, "code_block"):
                 continue
 
             for call in caller.code_block.function_calls:
                 if call.name != function.name:
                     continue
 
-                # Check if the argument types match the parameter types
+                # Check positional arguments
                 for i, arg in enumerate(call.args):
                     if i >= len(function.parameters):
                         break
 
                     param = function.parameters[i]
                     if not hasattr(arg, "type") or not arg.type:
                         continue
 
                     if arg.type != param.type_annotation:
                         self.errors.append(
                             CodeError(
                                 category=ErrorCategory.PARAMETER_TYPE_MISMATCH,
                                 severity=ErrorSeverity.ERROR,
                                 message=f"Type mismatch for parameter '{param.name}' in call to '{function.name}': expected '{param.type_annotation}', got '{arg.type}'",
                                 file_path=caller.filepath,
                                 function_name=caller.name,
                             )
                         )
+                
+                # Check keyword arguments if available
+                if hasattr(call, "kwargs"):
+                    for kwarg_name, kwarg_value in call.kwargs.items():
+                        # Find matching parameter
+                        matching_param = next((p for p in function.parameters if p.name == kwarg_name), None)
+                        if matching_param and hasattr(kwarg_value, "type") and kwarg_value.type:
+                            if kwarg_value.type != matching_param.type_annotation:
+                                self.errors.append(
+                                    CodeError(
+                                        category=ErrorCategory.PARAMETER_TYPE_MISMATCH,
+                                        severity=ErrorSeverity.ERROR,
+                                        message=f"Type mismatch for parameter '{matching_param.name}' in call to '{function.name}': expected '{matching_param.type_annotation}', got '{kwarg_value.type}'",
+                                        file_path=caller.filepath,
+                                        function_name=caller.name,
+                                    )
+                                )

 def _build_graph(self) -> None:
     """Build the function call graph."""
     # Initialize all functions as nodes in the graph
     for function in self.codebase.functions:
-        self.callers[function.name] = set()
-        self.callees[function.name] = set()
+        # Use fully qualified name (module.class.function) to avoid collisions
+        qualified_name = function.name
+        if hasattr(function, "module_name") and function.module_name:
+            qualified_name = f"{function.module_name}.{qualified_name}"
+        if hasattr(function, "class_name") and function.class_name:
+            qualified_name = f"{qualified_name}.{function.class_name}"
+            
+        self.callers[qualified_name] = set()
+        self.callees[qualified_name] = set()
 
     # Add edges for function calls
     for function in self.codebase.functions:
         if not hasattr(function, "code_block"):
             continue
+            
+        # Get qualified name for this function
+        caller_name = function.name
+        if hasattr(function, "module_name") and function.module_name:
+            caller_name = f"{function.module_name}.{caller_name}"
+        if hasattr(function, "class_name") and function.class_name:
+            caller_name = f"{caller_name}.{function.class_name}"
 
         for call in ...